diff --git a/Makefile b/Makefile index 77fe390..ada115e 100644 --- a/Makefile +++ b/Makefile @@ -1,7 +1,9 @@ REPO=$(shell dirname $(realpath $(lastword $(MAKEFILE_LIST)))) REPO_GOPATH=$(REPO)/go MINIFY=$(REPO_GOPATH)/bin/minify -JS=$(REPO)/contrib/static/nntpchan.js +STATIC_DIR=$(REPO)/contrib/static +JS=$(STATIC_DIR)/nntpchan.js +MINER_JS=$(STATIC_DIR)/miner-js.js CONTRIB_JS=$(REPO)/contrib/js/contrib LOCAL_JS=$(REPO)/contrib/js/nntpchan VENDOR_JS=$(REPO)/contrib/js/vendor @@ -15,6 +17,11 @@ NNTPD=$(REPO)/nntpd GOROOT=$(shell go env GOROOT) GO=$(GOROOT)/bin/go +GOPHERJS_GOROOT ?= $(GOROOT) +GOPHERJS_GO = $(GOPHERJS_GOROOT)/bin/go + +GOPHERJS=$(REPO_GOPATH)/bin/gopherjs + all: clean build build: js srnd @@ -23,14 +30,23 @@ full: clean full-build full-build: srnd beta native -js: $(JS) +js: $(JS) $(MINER_JS) srnd: $(SRND) $(MINIFY): - GOPATH=$(REPO_GOPATH) go get -v github.com/tdewolff/minify/cmd/minify + GOPATH=$(REPO_GOPATH) $(GO) get -v github.com/tdewolff/minify/cmd/minify -js-deps: $(MINIFY) +$(GOPHERJS): + GOPATH=$(REPO_GOPATH) $(GOPHERJS_GO) get -v github.com/gopherjs/gopherjs + +js-deps: $(MINIFY) $(MINER_JS) + +$(MINER_JS): $(GOPHERJS) $(MINIFY) + cp -rf $(SRND_DIR)/src/github.com $(REPO_GOPATH)/src/ + GOROOT=$(GOPHERJS_GOROOT) GOPATH=$(REPO_GOPATH) $(GOPHERJS) -m -v build github.com/ZiRo-/cuckgo/miner_js + $(MINIFY) --mime=text/javascript > $(STATIC_DIR)/miner-js.js < miner_js.js + rm -f miner_js.js.map miner_js.js $(JS): js-deps rm -f $(JS) @@ -70,16 +86,16 @@ test-native: GOROOT=$(GOROOT) $(MAKE) -C $(NNTPCHAN_DAEMON_DIR) test -clean: clean-js clean-srnd +clean: clean-srnd clean-js -clean-full: clean clean-beta clean-native +clean-full: clean clean-beta clean-native clean-js clean-srnd: rm -f $(SRND) GOROOT=$(GOROOT) $(MAKE) -C $(SRND_DIR) clean clean-js: - rm -f $(JS) + rm -f $(JS) $(MINER_JS) clean-beta: rm -f $(NNTPCHAND) diff --git a/contrib/backends/srndv2/src/github.com/ZiRo-/cuckgo/.gitignore b/contrib/backends/srndv2/src/github.com/ZiRo-/cuckgo/.gitignore new file mode 100644 index 0000000..e354b7f --- /dev/null +++ b/contrib/backends/srndv2/src/github.com/ZiRo-/cuckgo/.gitignore @@ -0,0 +1,11 @@ +*.pyc +*~ +*.ini +*.db +build.dir +\#* +.\#* +_obj +*.log +*.la +*.txt diff --git a/contrib/backends/srndv2/src/github.com/ZiRo-/cuckgo/LICENSE b/contrib/backends/srndv2/src/github.com/ZiRo-/cuckgo/LICENSE new file mode 100644 index 0000000..95924df --- /dev/null +++ b/contrib/backends/srndv2/src/github.com/ZiRo-/cuckgo/LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2016 ZiRo- + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/contrib/backends/srndv2/src/github.com/ZiRo-/cuckgo/README.md b/contrib/backends/srndv2/src/github.com/ZiRo-/cuckgo/README.md new file mode 100644 index 0000000..df21131 --- /dev/null +++ b/contrib/backends/srndv2/src/github.com/ZiRo-/cuckgo/README.md @@ -0,0 +1,41 @@ + +Cuckoo Cycle +============ +# Go implementation +This is a Go implementation of the cuckoo Proof of Work algorith "cuckoo cycle" by John Tromp. +This implementation includes the verification function as a library, and a simple multi-threaded miner. + +# Installation +To install this miner just run +`go get github.com/ZiRo-/cuckgo/miner` + +# Usage + +``` +Usage of miner: + -e float + easiness in percentage (default 50) + -m int + maximum number of solutions (default 8) + -t int + number of miner threads (default 4) +``` +# Algorithm + +For details about the algorith, see: https://github.com/tromp/cuckoo + +# Benchmarks +#### N = 100, Easiness = 55, Average time = 0.9 s, CPU = i5-4210U +![N = 100, Easiness = 55, Average time = 0.9 s, CPU = i5-4210U] (https://raw.githubusercontent.com/ZiRo-/cuckgo/master/bench/bench_N_100_e_55_avg_0.9.png) + +#### N = 100, Easiness = 50, Average time = 2.3 s, CPU = i5-4210U +![N = 100, Easiness = 50, Average time = 2.3 s, CPU = i5-4210U] (https://raw.githubusercontent.com/ZiRo-/cuckgo/master/bench/bench_N_100_e_50_avg_2.3.png) + +#### N = 300, Easiness = 46, Average time = 56.2 s, CPU = i5-4210U +![N = 300, Easiness = 46, Average time = 56.2 s, CPU = i5-4210U] (https://raw.githubusercontent.com/ZiRo-/cuckgo/master/bench/bench_N_300_e_46_avg_56.2.png) + +# JavaScript version +Using [GopherJS](https://github.com/gopherjs/gopherjs) the Go implementation can be transpiled to JavaScript, +which is also included in this repo. This file currently exports one function: +`cuckoo["mine_cuckoo"](easiness)` +which returns the same base64 representation of a proof as the Go CLI miner. diff --git a/contrib/backends/srndv2/src/github.com/ZiRo-/cuckgo/bench/bench_N_100_e_50_avg_2.3.png b/contrib/backends/srndv2/src/github.com/ZiRo-/cuckgo/bench/bench_N_100_e_50_avg_2.3.png new file mode 100644 index 0000000..5c773fd Binary files /dev/null and b/contrib/backends/srndv2/src/github.com/ZiRo-/cuckgo/bench/bench_N_100_e_50_avg_2.3.png differ diff --git a/contrib/backends/srndv2/src/github.com/ZiRo-/cuckgo/bench/bench_N_100_e_55_avg_0.9.png b/contrib/backends/srndv2/src/github.com/ZiRo-/cuckgo/bench/bench_N_100_e_55_avg_0.9.png new file mode 100644 index 0000000..c3a32dc Binary files /dev/null and b/contrib/backends/srndv2/src/github.com/ZiRo-/cuckgo/bench/bench_N_100_e_55_avg_0.9.png differ diff --git a/contrib/backends/srndv2/src/github.com/ZiRo-/cuckgo/bench/bench_N_300_e_46_avg_56.2.png b/contrib/backends/srndv2/src/github.com/ZiRo-/cuckgo/bench/bench_N_300_e_46_avg_56.2.png new file mode 100644 index 0000000..8fc6461 Binary files /dev/null and b/contrib/backends/srndv2/src/github.com/ZiRo-/cuckgo/bench/bench_N_300_e_46_avg_56.2.png differ diff --git a/contrib/backends/srndv2/src/github.com/ZiRo-/cuckgo/cuckoo/cuckoo-verify/verify_cli.go b/contrib/backends/srndv2/src/github.com/ZiRo-/cuckgo/cuckoo/cuckoo-verify/verify_cli.go new file mode 100644 index 0000000..e84e56c --- /dev/null +++ b/contrib/backends/srndv2/src/github.com/ZiRo-/cuckgo/cuckoo/cuckoo-verify/verify_cli.go @@ -0,0 +1,56 @@ +/* +The MIT License (MIT) + +Copyright (c) 2016 ZiRo + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. +*/ + +package main + +import ( + "encoding/base64" + "fmt" + "github.com/ZiRo-/cuckgo/cuckoo" + "os" +) + +func main() { + if len(os.Args) < 2 { + os.Exit(3) + } + + data, err := base64.StdEncoding.DecodeString(os.Args[1]) + if err != nil { + fmt.Println("error:", err) + os.Exit(2) + } + cuck, err := cuckoo.DecodeCuckooJSON(data) + if err != nil { + fmt.Println("error:", err) + os.Exit(2) + } + //fmt.Println(cuck) + + if cuckoo.VerifyJSON(*cuck) { + fmt.Println("Valid") + os.Exit(0) + } else { + fmt.Println("Invalid") + os.Exit(1) + } +} diff --git a/contrib/backends/srndv2/src/github.com/ZiRo-/cuckgo/cuckoo/cuckoo.go b/contrib/backends/srndv2/src/github.com/ZiRo-/cuckgo/cuckoo/cuckoo.go new file mode 100644 index 0000000..be99e83 --- /dev/null +++ b/contrib/backends/srndv2/src/github.com/ZiRo-/cuckgo/cuckoo/cuckoo.go @@ -0,0 +1,232 @@ +/* +The MIT License (MIT) + +Copyright (c) 2016 ZiRo + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. +*/ + +package cuckoo + +import "crypto/sha256" + +const ( + SIZESHIFT uint64 = 20 + PROOFSIZE uint64 = 42 + SIZE uint64 = 1 << SIZESHIFT + HALFSIZE uint64 = SIZE / 2 + NODEMASK uint64 = HALFSIZE - 1 +) + +type Cuckoo struct { + v [4]uint64 +} + +func u8(b byte) uint64 { + return (uint64)(b) & 0xff +} + +func u8to64(p [sha256.Size]byte, i int) uint64 { + return u8(p[i]) | u8(p[i+1])<<8 | + u8(p[i+2])<<16 | u8(p[i+3])<<24 | + u8(p[i+4])<<32 | u8(p[i+5])<<40 | + u8(p[i+6])<<48 | u8(p[i+7])<<56 +} + +func NewCuckoo(header []byte) *Cuckoo { + hdrkey := sha256.Sum256(header) + + return NewCuckooSHA(hdrkey) +} + +func NewCuckooSHA(hdrkey [sha256.Size]byte) *Cuckoo { + self := new(Cuckoo) + k0 := u8to64(hdrkey, 0) + k1 := u8to64(hdrkey, 8) + self.v[0] = k0 ^ 0x736f6d6570736575 + self.v[1] = k1 ^ 0x646f72616e646f6d + self.v[2] = k0 ^ 0x6c7967656e657261 + self.v[3] = k1 ^ 0x7465646279746573 + + return self +} + +type Edge struct { + U uint64 + V uint64 +} + +func (self *Edge) HashCode() int { + return int(self.U) ^ int(self.V) +} + +func (self *Cuckoo) Sipedge(nonce uint64) *Edge { + return &Edge{self.Sipnode(nonce, 0), self.Sipnode(nonce, 1)} +} + +func (self *Cuckoo) siphash24(nonce uint64) uint64 { + v0 := self.v[0] + v1 := self.v[1] + v2 := self.v[2] + v3 := self.v[3] ^ nonce + + v0 += v1 + v2 += v3 + v1 = (v1 << 13) | v1>>51 + v3 = (v3 << 16) | v3>>48 + v1 ^= v0 + v3 ^= v2 + v0 = (v0 << 32) | v0>>32 + v2 += v1 + v0 += v3 + v1 = (v1 << 17) | v1>>47 + v3 = (v3 << 21) | v3>>43 + v1 ^= v2 + v3 ^= v0 + v2 = (v2 << 32) | v2>>32 + + v0 += v1 + v2 += v3 + v1 = (v1 << 13) | v1>>51 + v3 = (v3 << 16) | v3>>48 + v1 ^= v0 + v3 ^= v2 + v0 = (v0 << 32) | v0>>32 + v2 += v1 + v0 += v3 + v1 = (v1 << 17) | v1>>47 + v3 = (v3 << 21) | v3>>43 + v1 ^= v2 + v3 ^= v0 + v2 = (v2 << 32) | v2>>32 + + v0 ^= nonce + v2 ^= 0xff + + v0 += v1 + v2 += v3 + v1 = (v1 << 13) | v1>>51 + v3 = (v3 << 16) | v3>>48 + v1 ^= v0 + v3 ^= v2 + v0 = (v0 << 32) | v0>>32 + v2 += v1 + v0 += v3 + v1 = (v1 << 17) | v1>>47 + v3 = (v3 << 21) | v3>>43 + v1 ^= v2 + v3 ^= v0 + v2 = (v2 << 32) | v2>>32 + + v0 += v1 + v2 += v3 + v1 = (v1 << 13) | v1>>51 + v3 = (v3 << 16) | v3>>48 + v1 ^= v0 + v3 ^= v2 + v0 = (v0 << 32) | v0>>32 + v2 += v1 + v0 += v3 + v1 = (v1 << 17) | v1>>47 + v3 = (v3 << 21) | v3>>43 + v1 ^= v2 + v3 ^= v0 + v2 = (v2 << 32) | v2>>32 + + v0 += v1 + v2 += v3 + v1 = (v1 << 13) | v1>>51 + v3 = (v3 << 16) | v3>>48 + v1 ^= v0 + v3 ^= v2 + v0 = (v0 << 32) | v0>>32 + v2 += v1 + v0 += v3 + v1 = (v1 << 17) | v1>>47 + v3 = (v3 << 21) | v3>>43 + v1 ^= v2 + v3 ^= v0 + v2 = (v2 << 32) | v2>>32 + + v0 += v1 + v2 += v3 + v1 = (v1 << 13) | v1>>51 + v3 = (v3 << 16) | v3>>48 + v1 ^= v0 + v3 ^= v2 + v0 = (v0 << 32) | v0>>32 + v2 += v1 + v0 += v3 + v1 = (v1 << 17) | v1>>47 + v3 = (v3 << 21) | v3>>43 + v1 ^= v2 + v3 ^= v0 + v2 = (v2 << 32) | v2>>32 + return v0 ^ v1 ^ v2 ^ v3 +} + +// generate edge in cuckoo graph +func (self *Cuckoo) Sipnode(nonce uint64, uorv uint32) uint64 { + return self.siphash24(2*nonce+uint64(uorv)) & NODEMASK +} + +// verify that (ascending) nonces, all less than easiness, form a cycle in graph +func (self *Cuckoo) Verify(nonces []uint64, easiness uint64) bool { + us := make([]uint64, PROOFSIZE) + vs := make([]uint64, PROOFSIZE) + i := 0 + var n uint64 + + for n = 0; n < PROOFSIZE; n++ { + if nonces[n] >= easiness || (n != 0 && nonces[n] <= nonces[n-1]) { + return false + } + us[n] = self.Sipnode(nonces[n], 0) + vs[n] = self.Sipnode(nonces[n], 1) + } + + loop := true + for loop { // follow cycle until we return to i==0; n edges left to visit + j := i + for k := 0; uint64(k) < PROOFSIZE; k++ { // find unique other j with same vs[j] + if k != i && vs[k] == vs[i] { + if j != i { + return false + } + j = k + } + } + if j == i { + return false + } + i = j + for k := 0; uint64(k) < PROOFSIZE; k++ { // find unique other i with same us[i] + if k != j && us[k] == us[j] { + if i != j { + return false + } + i = k + } + } + if i == j { + return false + } + n -= 2 + loop = (i != 0) + } + return n == 0 +} diff --git a/contrib/backends/srndv2/src/github.com/ZiRo-/cuckgo/cuckoo/verify-json.go b/contrib/backends/srndv2/src/github.com/ZiRo-/cuckgo/cuckoo/verify-json.go new file mode 100644 index 0000000..8d11765 --- /dev/null +++ b/contrib/backends/srndv2/src/github.com/ZiRo-/cuckgo/cuckoo/verify-json.go @@ -0,0 +1,69 @@ +/* +The MIT License (MIT) + +Copyright (c) 2016 ZiRo + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. +*/ + +package cuckoo + +import ( + "crypto/sha256" + "encoding/json" +) + +type CuckooJSON struct { + Parameter map[string]uint64 `json:"parameters"` + InputData []byte `json:"header"` //sha256 bytes + Cycle []uint64 `json:"cycle"` +} + +func DecodeCuckooJSON(jsonBlob []byte) (*CuckooJSON, error) { + res := new(CuckooJSON) + err := json.Unmarshal(jsonBlob, res) + if err != nil { + return nil, err + } + return res, nil +} + +func EncodeCuckooJSON(cuck CuckooJSON) ([]byte, error) { + return json.Marshal(cuck) +} + +func VerifyJSON(cuck CuckooJSON) bool { + easy := cuck.Parameter["easiness"] + + if easy <= 0 || easy >= SIZE { + return false + } + + if len(cuck.InputData) != sha256.Size { + return false + } + + if uint64(len(cuck.Cycle)) != PROOFSIZE { + return false + } + + var sha [sha256.Size]byte + copy(sha[:], cuck.InputData) + + c := NewCuckooSHA(sha) + return c.Verify(cuck.Cycle, easy) +} diff --git a/contrib/backends/srndv2/src/github.com/ZiRo-/cuckgo/miner/miner-cli.go b/contrib/backends/srndv2/src/github.com/ZiRo-/cuckgo/miner/miner-cli.go new file mode 100644 index 0000000..c4b9a16 --- /dev/null +++ b/contrib/backends/srndv2/src/github.com/ZiRo-/cuckgo/miner/miner-cli.go @@ -0,0 +1,54 @@ +/* +The MIT License (MIT) + +Copyright (c) 2016 ZiRo + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. +*/ + +package main + +import ( + "flag" + "fmt" + "github.com/ZiRo-/cuckgo/miner/miner_lib" + "runtime" +) + +var nthreads int +var maxsols int +var easipct float64 + +//var header string + +func init() { + flag.IntVar(&nthreads, "t", 0, "number of miner threads") + flag.IntVar(&maxsols, "m", 8, "maximum number of solutions") + flag.Float64Var(&easipct, "e", 50.0, "easiness in percentage") + //flag.StringVar(&header, "h", "cuck", "Header") +} + +func main() { + flag.Parse() + if (nthreads < 1) { + nthreads = runtime.NumCPU() + } + //fmt.Println("Looking for", cuckoo.PROOFSIZE, "-cycle on cuckoo", cuckoo.SIZESHIFT, "with", easipct, "% edges and", nthreads, "threads") + c := miner_lib.Mine(easipct, maxsols, nthreads) + fmt.Println(c.String()) +} + diff --git a/contrib/backends/srndv2/src/github.com/ZiRo-/cuckgo/miner/miner_lib/cuckoo-miner-lib.go b/contrib/backends/srndv2/src/github.com/ZiRo-/cuckgo/miner/miner_lib/cuckoo-miner-lib.go new file mode 100644 index 0000000..c795795 --- /dev/null +++ b/contrib/backends/srndv2/src/github.com/ZiRo-/cuckgo/miner/miner_lib/cuckoo-miner-lib.go @@ -0,0 +1,292 @@ +/* +The MIT License (MIT) + +Copyright (c) 2016 ZiRo + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. +*/ + +package miner_lib + +import ( + "crypto/rand" + "crypto/sha256" + "encoding/base64" + "github.com/ZiRo-/cuckgo/cuckoo" + "sync" +) + +const MAXPATHLEN = 4096 +const RANDOFFS = 64 +const MAXLEN = 1024 + +type CuckooSolve struct { + graph *cuckoo.Cuckoo + easiness int + cuckoo []int + sols [][]int + nsols int + nthreads int +} + +type CuckooProof struct { + solve *CuckooSolve + b []byte +} + +func NewCuckooSolve(hdr []byte, en, ms, nt int) *CuckooSolve { + self := &CuckooSolve{ + graph: cuckoo.NewCuckoo(hdr), + easiness: en, + sols: make([][]int, 2*ms), //this isn't completley safe for high easiness + cuckoo: make([]int, 1+int(cuckoo.SIZE)), + nsols: 0, + nthreads: 1, + } + for i := range self.sols { + self.sols[i] = make([]int, cuckoo.PROOFSIZE) + } + return self +} + +func (self *CuckooSolve) path(u int, us []int, done chan int) int { + nu := 0 + for nu = 0; u != 0; u = self.cuckoo[u] { + nu++ + if nu >= MAXPATHLEN { + for nu != 0 && us[nu-1] != u { + nu-- + } + if nu < 0 { + //fmt.Println("maximum path length exceeded") + } else { + //fmt.Println("illegal", (MAXPATHLEN - nu), "-cycle") + } + close(done) + return -1 + } + us[nu] = u + } + return nu +} + +func (self *CuckooSolve) solution(us []int, nu int, vs []int, nv int) { + cycle := make(map[int]*cuckoo.Edge) + n := 0 + edg := &cuckoo.Edge{uint64(us[0]), uint64(vs[0]) - cuckoo.HALFSIZE} + cycle[edg.HashCode()] = edg + for nu != 0 { // u's in even position; v's in odd + nu-- + edg := &cuckoo.Edge{uint64(us[(nu+1)&^1]), uint64(us[nu|1]) - cuckoo.HALFSIZE} + _, has := cycle[edg.HashCode()] + if !has { + cycle[edg.HashCode()] = edg + } + } + for nv != 0 { // u's in odd position; v's in even + nv-- + edg := &cuckoo.Edge{uint64(vs[nv|1]), uint64(vs[(nv+1)&^1]) - cuckoo.HALFSIZE} + _, has := cycle[edg.HashCode()] + if !has { + cycle[edg.HashCode()] = edg + } + } + n = 0 + for nonce := 0; nonce < self.easiness; nonce++ { + e := self.graph.Sipedge(uint64(nonce)) + has, key := contains(cycle, e) + if has { + self.sols[self.nsols][n] = nonce + n++ + delete(cycle, key) + } + } + if uint64(n) == cuckoo.PROOFSIZE { + self.nsols++ + } else { + //fmt.Println("Only recovered ", n, " nonces") + } +} + +func contains(m map[int]*cuckoo.Edge, e *cuckoo.Edge) (bool, int) { + h := e.HashCode() + for k, v := range m { + if k == h && v.U == e.U && v.V == e.V { //fuck Java for making me waste time just to figure out that that's how Java does contains + return true, k + } + } + return false, 0 +} + +func worker(id int, solve *CuckooSolve, done chan int) { + cuck := solve.cuckoo + us := make([]int, MAXPATHLEN) + vs := make([]int, MAXPATHLEN) + for nonce := id; nonce < solve.easiness; nonce += solve.nthreads { + us[0] = (int)(solve.graph.Sipnode(uint64(nonce), 0)) + u := cuck[us[0]] + vs[0] = (int)(cuckoo.HALFSIZE + solve.graph.Sipnode(uint64(nonce), 1)) + v := cuck[vs[0]] + if u == vs[0] || v == us[0] { + continue // ignore duplicate edges + } + nu := solve.path(u, us, done) + nv := solve.path(v, vs, done) + + if nu == -1 || nv == -1 { + return + } + + if us[nu] == vs[nv] { + min := 0 + if nu < nv { + min = nu + } else { + min = nv + } + nu -= min + nv -= min + for us[nu] != vs[nv] { + nu++ + nv++ + } + length := nu + nv + 1 + //fmt.Println(" " , length , "-cycle found at " , id , ":" , (int)(nonce*100/solve.easiness) , "%") + if uint64(length) == cuckoo.PROOFSIZE && solve.nsols < len(solve.sols) { + solve.solution(us, nu, vs, nv) + } + continue + } + if nu < nv { + for nu != 0 { + nu-- + cuck[us[nu+1]] = us[nu] + } + cuck[us[0]] = vs[0] + } else { + for nv != 0 { + nv-- + cuck[vs[nv+1]] = vs[nv] + } + cuck[vs[0]] = us[0] + } + } + close(done) +} + +func Mine(easipct float64, maxsols, nthreads int) *CuckooProof { + b := make([]byte, RANDOFFS) + _, err := rand.Read(b) + if err != nil { + panic(err) + } + easy := int(easipct * float64(cuckoo.SIZE) / 100.0) + solve := NewCuckooSolve(b, easy, maxsols, 1) + + for k := 0; k < MAXLEN-RANDOFFS; k++ { + b = append(b, 0) + for i := 0; i < 256; i += nthreads { + + cs := make([]chan int, nthreads) + solvers := make([]*CuckooSolve, nthreads) + for n := 0; n < nthreads; n++ { + cs[n] = make(chan int) + } + out := merge(cs...) + + for n := 0; n < nthreads; n++ { + if i+n < 256 { + b[RANDOFFS+k] = byte(i + n) + solvers[n] = NewCuckooSolve(b, easy, maxsols, 1) + go worker(i, solvers[n], cs[n]) + } else { + close(cs[n]) + } + } + + <-out + + for n, s := range solvers { + if s.nsols > 0 { + b[RANDOFFS+k] = byte(i + n) + solve = s + goto done + } + } + } + } + +done: + /* for s := 0; s < solve.nsols; s++ { + //fmt.Print("Solution") + for i := 0; uint64(i) < cuckoo.PROOFSIZE; i++ { + fmt.Printf(" %x", solve.sols[s][i]) + } + fmt.Println() + }*/ + if solve.nsols <= 0 { + solve = nil + } + return &CuckooProof{solve, b} +} + +func (self *CuckooProof)String() string { + c := formatProof(self.solve, self.b) + json, _ := cuckoo.EncodeCuckooJSON(c) + return base64.StdEncoding.EncodeToString(json) +} + + +func formatProof(solve *CuckooSolve, b []byte) cuckoo.CuckooJSON { + sha := sha256.Sum256(b) + easy := uint64(solve.easiness) + cycle := make([]uint64, len(solve.sols[0])) + m := make(map[string]uint64) + m["easiness"] = easy + + for i, n := range solve.sols[0] { + cycle[i] = uint64(n) + } + + return cuckoo.CuckooJSON{m, sha[:], cycle} +} + +func merge(cs ...chan int) chan int { + var wg sync.WaitGroup + out := make(chan int) + + // Start an output goroutine for each input channel in cs. output + // copies values from c to out until c is closed, then calls wg.Done. + output := func(c chan int) { + for n := range c { + out <- n + } + wg.Done() + } + wg.Add(len(cs)) + for _, c := range cs { + go output(c) + } + + // Start a goroutine to close out once all the output goroutines are + // done. This must start after the wg.Add call. + go func() { + wg.Wait() + close(out) + }() + return out +} diff --git a/contrib/backends/srndv2/src/github.com/ZiRo-/cuckgo/miner_js/cuckoo.go b/contrib/backends/srndv2/src/github.com/ZiRo-/cuckgo/miner_js/cuckoo.go new file mode 100644 index 0000000..b835f47 --- /dev/null +++ b/contrib/backends/srndv2/src/github.com/ZiRo-/cuckgo/miner_js/cuckoo.go @@ -0,0 +1,155 @@ +/* +The MIT License (MIT) + +Copyright (c) 2016 ZiRo + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. +*/ + +package main + +import "crypto/sha256" +import "github.com/gopherjs/gopherjs/js" + +const ( + SIZESHIFT uint64 = 20 + PROOFSIZE uint64 = 42 + SIZE uint64 = 1 << SIZESHIFT + HALFSIZE uint64 = SIZE / 2 + NODEMASK uint64 = HALFSIZE - 1 +) + +type Cuckoo struct { + v [4]uint64 + vh [4]uint32 + vl [4]uint32 + key []byte +} + +func u8(b byte) uint64 { + return (uint64)(b) & 0xff +} + +func u8to64(p [sha256.Size]byte, i int) uint64 { + return u8(p[i]) | u8(p[i+1])<<8 | + u8(p[i+2])<<16 | u8(p[i+3])<<24 | + u8(p[i+4])<<32 | u8(p[i+5])<<40 | + u8(p[i+6])<<48 | u8(p[i+7])<<56 +} + +func NewCuckoo(header []byte) *Cuckoo { + hdrkey := sha256.Sum256(header) + + return NewCuckooSHA(hdrkey) +} + +func NewCuckooSHA(hdrkey [sha256.Size]byte) *Cuckoo { + self := new(Cuckoo) + k0 := u8to64(hdrkey, 0) + k1 := u8to64(hdrkey, 8) + self.v[0] = k0 ^ 0x736f6d6570736575 + self.v[1] = k1 ^ 0x646f72616e646f6d + self.v[2] = k0 ^ 0x6c7967656e657261 + self.v[3] = k1 ^ 0x7465646279746573 + self.key = hdrkey[:] + + for i,h := range(self.v) { + self.vl[i] = uint32 (h & 0xFFFFFFFF); + self.vh[i] = uint32((h & (0xFFFFFFFF << 32) ) >> 32); + } + + return self +} + +type Edge struct { + U uint64 + V uint64 +} + +func (self *Edge) HashCode() int { + return int(self.U) ^ int(self.V) +} + +func (self *Cuckoo) Sipedge(nonce uint64) *Edge { + return &Edge{self.Sipnode(nonce, 0), self.Sipnode(nonce, 1)} +} + +func (self *Cuckoo) siphash24(nonce uint64) uint64 { + return siphash24_js(self.vh, self.vl, nonce) +} + +var sh *js.Object = js.Global.Get("SipHash") + +func siphash24_js(vh, vl [4]uint32, nonce uint64) uint64 { + arr := sh.Call("hash", vh[0], vl[0], vh[1], vl[1], vh[2], vl[2], vh[3], vl[3], 0, nonce) + high := arr.Index(0).Uint64(); + low := arr.Index(1).Uint64(); + + return (high << 32) | low; +} + +// generate edge in cuckoo graph +func (self *Cuckoo) Sipnode(nonce uint64, uorv uint32) uint64 { + return self.siphash24(2*nonce+uint64(uorv)) & NODEMASK +} + +// verify that (ascending) nonces, all less than easiness, form a cycle in graph +func (self *Cuckoo) Verify(nonces []uint64, easiness uint64) bool { + us := make([]uint64, PROOFSIZE) + vs := make([]uint64, PROOFSIZE) + i := 0 + var n uint64 + + for n = 0; n < PROOFSIZE; n++ { + if nonces[n] >= easiness || (n != 0 && nonces[n] <= nonces[n-1]) { + return false + } + us[n] = self.Sipnode(nonces[n], 0) + vs[n] = self.Sipnode(nonces[n], 1) + } + + loop := true + for loop { // follow cycle until we return to i==0; n edges left to visit + j := i + for k := 0; uint64(k) < PROOFSIZE; k++ { // find unique other j with same vs[j] + if k != i && vs[k] == vs[i] { + if j != i { + return false + } + j = k + } + } + if j == i { + return false + } + i = j + for k := 0; uint64(k) < PROOFSIZE; k++ { // find unique other i with same us[i] + if k != j && us[k] == us[j] { + if i != j { + return false + } + i = k + } + } + if i == j { + return false + } + n -= 2 + loop = (i != 0) + } + return n == 0 +} diff --git a/contrib/backends/srndv2/src/github.com/ZiRo-/cuckgo/miner_js/miner-js.go b/contrib/backends/srndv2/src/github.com/ZiRo-/cuckgo/miner_js/miner-js.go new file mode 100644 index 0000000..5acb91b --- /dev/null +++ b/contrib/backends/srndv2/src/github.com/ZiRo-/cuckgo/miner_js/miner-js.go @@ -0,0 +1,226 @@ +/* +The MIT License (MIT) + +Copyright (c) 2016 ZiRo + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. +*/ + +package main + +import ( + "crypto/sha256" + "encoding/base64" + "github.com/gopherjs/gopherjs/js" +) + +const MAXPATHLEN = 4096 +const RANDOFFS = 64 +const MAXLEN = 1024 + +type CuckooSolve struct { + graph *Cuckoo + easiness int + cuckoo []int + sols [][]int + nsols int + nthreads int +} + +func NewCuckooSolve(hdr []byte, en, ms, nt int) *CuckooSolve { + self := &CuckooSolve{ + graph: NewCuckoo(hdr), + easiness: en, + sols: make([][]int, 2*ms), //this isn't completley safe for high easiness + cuckoo: make([]int, 1+int(SIZE)), + nsols: 0, + nthreads: 1, + } + for i := range self.sols { + self.sols[i] = make([]int, PROOFSIZE) + } + return self +} + +func (self *CuckooSolve) path(u int, us []int) int { + nu := 0 + for nu = 0; u != 0; u = self.cuckoo[u] { + nu++ + if nu >= MAXPATHLEN { + for nu != 0 && us[nu-1] != u { + nu-- + } + if nu < 0 { + //fmt.Println("maximum path length exceeded") + } else { + //fmt.Println("illegal", (MAXPATHLEN - nu), "-cycle") + } + return -1 + } + us[nu] = u + } + return nu +} + +func (self *CuckooSolve) solution(us []int, nu int, vs []int, nv int) bool { + cycle := make(map[int]*Edge) + n := 0 + edg := &Edge{uint64(us[0]), uint64(vs[0]) - HALFSIZE} + cycle[edg.HashCode()] = edg + for nu != 0 { // u's in even position; v's in odd + nu-- + edg := &Edge{uint64(us[(nu+1)&^1]), uint64(us[nu|1]) - HALFSIZE} + _, has := cycle[edg.HashCode()] + if !has { + cycle[edg.HashCode()] = edg + } + } + for nv != 0 { // u's in odd position; v's in even + nv-- + edg := &Edge{uint64(vs[nv|1]), uint64(vs[(nv+1)&^1]) - HALFSIZE} + _, has := cycle[edg.HashCode()] + if !has { + cycle[edg.HashCode()] = edg + } + } + n = 0 + for nonce := 0; nonce < self.easiness; nonce++ { + e := self.graph.Sipedge(uint64(nonce)) + has, key := contains(cycle, e) + if has { + self.sols[self.nsols][n] = nonce + n++ + delete(cycle, key) + } + } + if uint64(n) == PROOFSIZE { + self.nsols++ + return true + } else { + //fmt.Println("Only recovered ", n, " nonces") + } + return false +} + +func contains(m map[int]*Edge, e *Edge) (bool, int) { + h := e.HashCode() + for k, v := range m { + if k == h && v.U == e.U && v.V == e.V { //fuck Java for making me waste time just to figure out that that's how Java does contains + return true, k + } + } + return false, 0 +} + +func worker(id int, solve *CuckooSolve) { + cuck := solve.cuckoo + us := make([]int, MAXPATHLEN) + vs := make([]int, MAXPATHLEN) + for nonce := id; nonce < solve.easiness; nonce += solve.nthreads { + us[0] = (int)(solve.graph.Sipnode(uint64(nonce), 0)) + u := cuck[us[0]] + vs[0] = (int)(HALFSIZE + solve.graph.Sipnode(uint64(nonce), 1)) + v := cuck[vs[0]] + if u == vs[0] || v == us[0] { + continue // ignore duplicate edges + } + nu := solve.path(u, us) + nv := solve.path(v, vs) + + if nu == -1 || nv == -1 { + return + } + + if us[nu] == vs[nv] { + min := 0 + if nu < nv { + min = nu + } else { + min = nv + } + nu -= min + nv -= min + for us[nu] != vs[nv] { + nu++ + nv++ + } + length := nu + nv + 1 + //fmt.Println(" " , length , "-cycle found at " , id , ":" , (int)(nonce*100/solve.easiness) , "%") + if uint64(length) == PROOFSIZE && solve.nsols < len(solve.sols) { + if solve.solution(us, nu, vs, nv) { + break; + } + } + continue + } + if nu < nv { + for nu != 0 { + nu-- + cuck[us[nu+1]] = us[nu] + } + cuck[us[0]] = vs[0] + } else { + for nv != 0 { + nv-- + cuck[vs[nv+1]] = vs[nv] + } + cuck[vs[0]] = us[0] + } + } +} + +func mine_cuckoo(b []byte, easipct float64) []string { + easy := int(easipct * float64(SIZE) / 100.0) + + solve := NewCuckooSolve(b, easy, 8, 1) + worker(0, solve) + + + res := make([]string, 2) + if solve.nsols > 0 { + c := formatProof(solve, b) + json, _ := EncodeCuckooJSON(c) + str := base64.StdEncoding.EncodeToString(json) + res[0] = "ok" + res[1] = str + } else { + res[0] = "D^:" + } + return res +} + +func formatProof(solve *CuckooSolve, b []byte) CuckooJSON { + sha := sha256.Sum256(b) + easy := uint64(solve.easiness) + cycle := make([]uint64, len(solve.sols[0])) + m := make(map[string]uint64) + m["easiness"] = easy + + for i, n := range solve.sols[0] { + cycle[i] = uint64(n) + } + + return CuckooJSON{m, sha[:], cycle} +} + + + +func main() { + js.Global.Set("cuckoo", map[string]interface{}{ + "mine_cuckoo": mine_cuckoo, + }) +} diff --git a/contrib/backends/srndv2/src/github.com/ZiRo-/cuckgo/miner_js/miner_js.js b/contrib/backends/srndv2/src/github.com/ZiRo-/cuckgo/miner_js/miner_js.js new file mode 100644 index 0000000..eaf0808 --- /dev/null +++ b/contrib/backends/srndv2/src/github.com/ZiRo-/cuckgo/miner_js/miner_js.js @@ -0,0 +1,23312 @@ +"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 fn(new ($sliceType($jsObjectPtr))($global.Array.prototype.slice.call(arguments, []))); } }; + +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 (low < 0 || high < low || max < high || high > slice.$capacity || max > slice.$capacity) { + $throwRuntimeError("slice bounds out of range"); + } + var s = new slice.constructor(slice.$array); + s.$offset = slice.$offset + low; + s.$length = slice.$length - low; + s.$capacity = slice.$capacity - low; + if (high !== undefined) { + s.$length = high - low; + } + if (max !== undefined) { + s.$capacity = max - low; + } + return s; +}; + +var $sliceToArray = function(slice) { + if (slice.$length === 0) { + return []; + } + 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, name, pkg, 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, "", "", 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, "", "", 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(fields) { + 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.name === "") { + $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.typeName = name; + typ.pkg = pkg; + 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.typeName !== "") { + 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.name === "") { + 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", "bool", "", null); +var $Int = $newType( 4, $kindInt, "int", "int", "", null); +var $Int8 = $newType( 1, $kindInt8, "int8", "int8", "", null); +var $Int16 = $newType( 2, $kindInt16, "int16", "int16", "", null); +var $Int32 = $newType( 4, $kindInt32, "int32", "int32", "", null); +var $Int64 = $newType( 8, $kindInt64, "int64", "int64", "", null); +var $Uint = $newType( 4, $kindUint, "uint", "uint", "", null); +var $Uint8 = $newType( 1, $kindUint8, "uint8", "uint8", "", null); +var $Uint16 = $newType( 2, $kindUint16, "uint16", "uint16", "", null); +var $Uint32 = $newType( 4, $kindUint32, "uint32", "uint32", "", null); +var $Uint64 = $newType( 8, $kindUint64, "uint64", "uint64", "", null); +var $Uintptr = $newType( 4, $kindUintptr, "uintptr", "uintptr", "", null); +var $Float32 = $newType( 4, $kindFloat32, "float32", "float32", "", null); +var $Float64 = $newType( 8, $kindFloat64, "float64", "float64", "", null); +var $Complex64 = $newType( 8, $kindComplex64, "complex64", "complex64", "", null); +var $Complex128 = $newType(16, $kindComplex128, "complex128", "complex128", "", null); +var $String = $newType( 8, $kindString, "string", "string", "", null); +var $UnsafePointer = $newType( 4, $kindUnsafePointer, "unsafe.Pointer", "Pointer", "", 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, "", "", 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, "", "", 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, "", "", 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, "", "", null); + $interfaceTypes[typeKey] = typ; + typ.init(methods); + } + return typ; +}; +var $emptyInterface = $interfaceType([]); +var $ifaceNil = {}; +var $error = $newType(8, $kindInterface, "error", "error", "", 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, "", "", 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, "", "", 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, "", "", 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(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, "", "", 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(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("", (value === $ifaceNil ? "" : value.constructor.string), 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 $dummyGoroutine = { asleep: false, exit: false, deferStack: [], panicStack: [], canBlock: false }; +var $curGoroutine = $dummyGoroutine, $totalGoroutines = 0, $awakeGoroutines = 0, $checkForDeadlock = true; +var $mainFinished = false; +var $go = function(fun, args, direct) { + $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 = $dummyGoroutine; + 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 = []; + $goroutine.canBlock = true; + $schedule($goroutine, direct); +}; + +var $scheduled = [], $schedulerActive = false; +var $runScheduled = function() { + try { + var r; + while ((r = $scheduled.shift()) !== undefined) { + r(); + } + $schedulerActive = false; + } finally { + if ($schedulerActive) { + setTimeout($runScheduled, 0); + } + } +}; +var $schedule = function(goroutine, direct) { + if (goroutine.asleep) { + goroutine.asleep = false; + $awakeGoroutines++; + } + + if (direct) { + goroutine(); + return; + } + + $scheduled.push(goroutine); + if (!$schedulerActive) { + $schedulerActive = true; + setTimeout($runScheduled, 0); + } +}; + +var $setTimeout = function(f, t) { + $awakeGoroutines++; + return setTimeout(function() { + $awakeGoroutines--; + f(); + }, t); +}; + +var $block = function() { + if (!$curGoroutine.canBlock) { + $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; + chan.$sendQueue.push(function() { + $schedule(thisGoroutine); + return value; + }); + $block(); + return { + $blk: function() { + if (chan.$closed) { + $throwRuntimeError("send on closed channel"); + } + } + }; +}; +var $recv = function(chan) { + var queuedSend = chan.$sendQueue.shift(); + if (queuedSend !== undefined) { + chan.$buffer.push(queuedSend()); + } + 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(); /* will panic because of closed channel */ + } + 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 (v.search(/^[\x00-\x7F]*$/) !== -1) { + 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.pkg !== "") { /* not 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 canBlock = $curGoroutine.canBlock; + $curGoroutine.canBlock = false; + try { + var result = v.apply(passThis ? this : undefined, args); + } finally { + $curGoroutine.canBlock = canBlock; + } + 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 (v.search(/^[\x00-\x7F]*$/) !== -1) { + 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); +}; + +$packages["github.com/gopherjs/gopherjs/js"] = (function() { + var $pkg = {}, $init, Object, Error, sliceType, ptrType, ptrType$1, init; + Object = $pkg.Object = $newType(0, $kindStruct, "js.Object", "Object", "github.com/gopherjs/gopherjs/js", function(object_) { + this.$val = this; + if (arguments.length === 0) { + this.object = null; + return; + } + this.object = object_; + }); + Error = $pkg.Error = $newType(0, $kindStruct, "js.Error", "Error", "github.com/gopherjs/gopherjs/js", 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 $ptr, 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 $ptr, 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 $ptr, 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 $ptr, o; + o = this; + return $parseInt(o.object.length); + }; + Object.prototype.Length = function() { return this.$val.Length(); }; + Object.ptr.prototype.Index = function(i) { + var $ptr, 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 $ptr, 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 $ptr, 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 $ptr, 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 $ptr, 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 $ptr, o; + o = this; + return !!(o.object); + }; + Object.prototype.Bool = function() { return this.$val.Bool(); }; + Object.ptr.prototype.String = function() { + var $ptr, o; + o = this; + return $internalize(o.object, $String); + }; + Object.prototype.String = function() { return this.$val.String(); }; + Object.ptr.prototype.Int = function() { + var $ptr, o; + o = this; + return $parseInt(o.object) >> 0; + }; + Object.prototype.Int = function() { return this.$val.Int(); }; + Object.ptr.prototype.Int64 = function() { + var $ptr, o; + o = this; + return $internalize(o.object, $Int64); + }; + Object.prototype.Int64 = function() { return this.$val.Int64(); }; + Object.ptr.prototype.Uint64 = function() { + var $ptr, o; + o = this; + return $internalize(o.object, $Uint64); + }; + Object.prototype.Uint64 = function() { return this.$val.Uint64(); }; + Object.ptr.prototype.Float = function() { + var $ptr, o; + o = this; + return $parseFloat(o.object); + }; + Object.prototype.Float = function() { return this.$val.Float(); }; + Object.ptr.prototype.Interface = function() { + var $ptr, o; + o = this; + return $internalize(o.object, $emptyInterface); + }; + Object.prototype.Interface = function() { return this.$val.Interface(); }; + Object.ptr.prototype.Unsafe = function() { + var $ptr, o; + o = this; + return o.object; + }; + Object.prototype.Unsafe = function() { return this.$val.Unsafe(); }; + Error.ptr.prototype.Error = function() { + var $ptr, 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 $ptr, err; + err = this; + return $internalize(err.Object.stack, $String); + }; + Error.prototype.Stack = function() { return this.$val.Stack(); }; + init = function() { + var $ptr, e; + e = new Error.ptr(null); + }; + 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([{prop: "object", name: "object", pkg: "github.com/gopherjs/gopherjs/js", typ: ptrType, tag: ""}]); + Error.init([{prop: "Object", name: "", pkg: "", 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["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, sys, Error, TypeAssertionError, errorString, ptrType$4, init, GOROOT, Goexit, GOMAXPROCS, SetFinalizer; + js = $packages["github.com/gopherjs/gopherjs/js"]; + sys = $packages["runtime/internal/sys"]; + Error = $pkg.Error = $newType(8, $kindInterface, "runtime.Error", "Error", "runtime", null); + TypeAssertionError = $pkg.TypeAssertionError = $newType(0, $kindStruct, "runtime.TypeAssertionError", "TypeAssertionError", "runtime", function(interfaceString_, concreteString_, assertedString_, missingMethod_) { + this.$val = this; + if (arguments.length === 0) { + this.interfaceString = ""; + this.concreteString = ""; + this.assertedString = ""; + this.missingMethod = ""; + return; + } + this.interfaceString = interfaceString_; + this.concreteString = concreteString_; + this.assertedString = assertedString_; + this.missingMethod = missingMethod_; + }); + errorString = $pkg.errorString = $newType(8, $kindString, "runtime.errorString", "errorString", "runtime", null); + ptrType$4 = $ptrType(TypeAssertionError); + init = function() { + var $ptr, e, jsPkg; + jsPkg = $packages[$externalize("github.com/gopherjs/gopherjs/js", $String)]; + $jsObjectPtr = jsPkg.Object.ptr; + $jsErrorPtr = jsPkg.Error.ptr; + $throwRuntimeError = (function(msg) { + var $ptr, msg; + $panic(new errorString(msg)); + }); + e = $ifaceNil; + e = new TypeAssertionError.ptr("", "", "", ""); + }; + GOROOT = function() { + var $ptr, goroot, process; + process = $global.process; + if (process === undefined) { + return "/"; + } + goroot = process.env.GOROOT; + if (!(goroot === undefined)) { + return $internalize(goroot, $String); + } + return "/home/mathias/src/go"; + }; + $pkg.GOROOT = GOROOT; + Goexit = function() { + var $ptr; + $curGoroutine.exit = $externalize(true, $Bool); + $throw(null); + }; + $pkg.Goexit = Goexit; + GOMAXPROCS = function(n) { + var $ptr, n; + return 1; + }; + $pkg.GOMAXPROCS = GOMAXPROCS; + SetFinalizer = function(x, f) { + var $ptr, f, x; + }; + $pkg.SetFinalizer = SetFinalizer; + TypeAssertionError.ptr.prototype.RuntimeError = function() { + var $ptr; + }; + TypeAssertionError.prototype.RuntimeError = function() { return this.$val.RuntimeError(); }; + TypeAssertionError.ptr.prototype.Error = function() { + var $ptr, e, inter; + e = this; + inter = e.interfaceString; + if (inter === "") { + inter = "interface"; + } + if (e.concreteString === "") { + return "interface conversion: " + inter + " is nil, not " + e.assertedString; + } + if (e.missingMethod === "") { + return "interface conversion: " + inter + " is " + e.concreteString + ", not " + e.assertedString; + } + return "interface conversion: " + e.concreteString + " is not " + e.assertedString + ": missing method " + e.missingMethod; + }; + TypeAssertionError.prototype.Error = function() { return this.$val.Error(); }; + errorString.prototype.RuntimeError = function() { + var $ptr, e; + e = this.$val; + }; + $ptrType(errorString).prototype.RuntimeError = function() { return new errorString(this.$get()).RuntimeError(); }; + errorString.prototype.Error = function() { + var $ptr, e; + e = this.$val; + return "runtime error: " + e; + }; + $ptrType(errorString).prototype.Error = function() { return new errorString(this.$get()).Error(); }; + 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)}]; + Error.init([{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}, {prop: "RuntimeError", name: "RuntimeError", pkg: "", typ: $funcType([], [], false)}]); + TypeAssertionError.init([{prop: "interfaceString", name: "interfaceString", pkg: "runtime", typ: $String, tag: ""}, {prop: "concreteString", name: "concreteString", pkg: "runtime", typ: $String, tag: ""}, {prop: "assertedString", name: "assertedString", pkg: "runtime", typ: $String, tag: ""}, {prop: "missingMethod", name: "missingMethod", pkg: "runtime", 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 = sys.$init(); /* */ $s = 2; case 2: 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", "errorString", "errors", function(s_) { + this.$val = this; + if (arguments.length === 0) { + this.s = ""; + return; + } + this.s = s_; + }); + ptrType = $ptrType(errorString); + New = function(text) { + var $ptr, text; + return new errorString.ptr(text); + }; + $pkg.New = New; + errorString.ptr.prototype.Error = function() { + var $ptr, 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([{prop: "s", name: "s", pkg: "errors", 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 $ptr, addr; + }; + $pkg.Acquire = Acquire; + Release = function(addr) { + var $ptr, addr; + }; + $pkg.Release = Release; + ReleaseMerge = function(addr) { + var $ptr, addr; + }; + $pkg.ReleaseMerge = ReleaseMerge; + Disable = function() { + var $ptr; + }; + $pkg.Disable = Disable; + Enable = function() { + var $ptr; + }; + $pkg.Enable = Enable; + ReadRange = function(addr, len) { + var $ptr, addr, len; + }; + $pkg.ReadRange = ReadRange; + WriteRange = function(addr, len) { + var $ptr, 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, CompareAndSwapInt32, AddInt32, LoadUint32, StoreUint32; + js = $packages["github.com/gopherjs/gopherjs/js"]; + CompareAndSwapInt32 = function(addr, old, new$1) { + var $ptr, addr, new$1, old; + if (addr.$get() === old) { + addr.$set(new$1); + return true; + } + return false; + }; + $pkg.CompareAndSwapInt32 = CompareAndSwapInt32; + AddInt32 = function(addr, delta) { + var $ptr, addr, delta, new$1; + new$1 = addr.$get() + delta >> 0; + addr.$set(new$1); + return new$1; + }; + $pkg.AddInt32 = AddInt32; + LoadUint32 = function(addr) { + var $ptr, addr; + return addr.$get(); + }; + $pkg.LoadUint32 = LoadUint32; + StoreUint32 = function(addr, val) { + var $ptr, addr, val; + addr.$set(val); + }; + $pkg.StoreUint32 = StoreUint32; + $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, race, runtime, atomic, Pool, Mutex, Locker, Once, poolLocal, syncSema, RWMutex, rlocker, ptrType, sliceType, ptrType$1, chanType, sliceType$1, ptrType$4, ptrType$6, sliceType$3, ptrType$7, ptrType$8, funcType, ptrType$12, funcType$1, ptrType$13, arrayType$1, semWaiters, allPools, runtime_Syncsemcheck, runtime_registerPoolCleanup, runtime_Semacquire, runtime_Semrelease, runtime_canSpin, poolCleanup, init, indexLocal, init$1, runtime_doSpin; + race = $packages["internal/race"]; + runtime = $packages["runtime"]; + atomic = $packages["sync/atomic"]; + Pool = $pkg.Pool = $newType(0, $kindStruct, "sync.Pool", "Pool", "sync", function(local_, localSize_, store_, New_) { + this.$val = this; + if (arguments.length === 0) { + this.local = 0; + this.localSize = 0; + this.store = sliceType$3.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", "Mutex", "sync", 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", "Locker", "sync", null); + Once = $pkg.Once = $newType(0, $kindStruct, "sync.Once", "Once", "sync", function(m_, done_) { + this.$val = this; + if (arguments.length === 0) { + this.m = new Mutex.ptr(0, 0); + this.done = 0; + return; + } + this.m = m_; + this.done = done_; + }); + poolLocal = $pkg.poolLocal = $newType(0, $kindStruct, "sync.poolLocal", "poolLocal", "sync", function(private$0_, shared_, Mutex_, pad_) { + this.$val = this; + if (arguments.length === 0) { + this.private$0 = $ifaceNil; + this.shared = sliceType$3.nil; + this.Mutex = new Mutex.ptr(0, 0); + this.pad = arrayType$1.zero(); + return; + } + this.private$0 = private$0_; + this.shared = shared_; + this.Mutex = Mutex_; + this.pad = pad_; + }); + syncSema = $pkg.syncSema = $newType(0, $kindStruct, "sync.syncSema", "syncSema", "sync", function(lock_, head_, tail_) { + this.$val = this; + if (arguments.length === 0) { + this.lock = 0; + this.head = 0; + this.tail = 0; + return; + } + this.lock = lock_; + this.head = head_; + this.tail = tail_; + }); + RWMutex = $pkg.RWMutex = $newType(0, $kindStruct, "sync.RWMutex", "RWMutex", "sync", 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", "rlocker", "sync", 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$4 = $ptrType($Int32); + ptrType$6 = $ptrType(poolLocal); + sliceType$3 = $sliceType($emptyInterface); + ptrType$7 = $ptrType(rlocker); + ptrType$8 = $ptrType(RWMutex); + funcType = $funcType([], [$emptyInterface], false); + ptrType$12 = $ptrType(Mutex); + funcType$1 = $funcType([], [], false); + ptrType$13 = $ptrType(Once); + arrayType$1 = $arrayType($Uint8, 128); + runtime_Syncsemcheck = function(size) { + var $ptr, size; + }; + Pool.ptr.prototype.Get = function() { + var $ptr, _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; $ptr = $f.$ptr; _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 = 6; case 6: + return _r; + /* } */ case 4: + 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") : x.$array[x.$offset + x$1])); + p.store = $subslice(p.store, 0, (p.store.$length - 1 >> 0)); + return x$2; + /* */ } return; } if ($f === undefined) { $f = { $blk: Pool.ptr.prototype.Get }; } $f.$ptr = $ptr; $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 $ptr, 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 $ptr, cleanup; + }; + runtime_Semacquire = function(s) { + var $ptr, _entry, _key, _r, ch, s, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _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$1.keyFor(_key)] = { k: _key, v: $append((_entry = semWaiters[ptrType$1.keyFor(s)], _entry !== undefined ? _entry.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]; + /* } */ case 2: + s.$set(s.$get() - (1) >>> 0); + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: runtime_Semacquire }; } $f.$ptr = $ptr; $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 $ptr, _entry, _key, ch, s, w, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _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$1.keyFor(s)], _entry !== undefined ? _entry.v : sliceType$1.nil); + if (w.$length === 0) { + return; + } + ch = (0 >= w.$length ? $throwRuntimeError("index out of range") : 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)]; + } + $r = $send(ch, true); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: runtime_Semrelease }; } $f.$ptr = $ptr; $f._entry = _entry; $f._key = _key; $f.ch = ch; $f.s = s; $f.w = w; $f.$s = $s; $f.$r = $r; return $f; + }; + runtime_canSpin = function(i) { + var $ptr, i; + return false; + }; + Mutex.ptr.prototype.Lock = function() { + var $ptr, awoke, iter, m, new$1, old, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; awoke = $f.awoke; iter = $f.iter; 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 (atomic.CompareAndSwapInt32((m.$ptr_state || (m.$ptr_state = new ptrType$4(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, m))), 0, 1)) { + if (false) { + race.Acquire(m); + } + return; + } + awoke = false; + iter = 0; + /* while (true) { */ case 1: + old = m.state; + new$1 = old | 1; + /* */ if (!(((old & 1) === 0))) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (!(((old & 1) === 0))) { */ case 3: + if (runtime_canSpin(iter)) { + if (!awoke && ((old & 2) === 0) && !(((old >> 2 >> 0) === 0)) && atomic.CompareAndSwapInt32((m.$ptr_state || (m.$ptr_state = new ptrType$4(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, m))), old, old | 2)) { + awoke = true; + } + runtime_doSpin(); + iter = iter + (1) >> 0; + /* continue; */ $s = 1; continue; + } + new$1 = old + 4 >> 0; + /* } */ case 4: + if (awoke) { + if ((new$1 & 2) === 0) { + $panic(new $String("sync: inconsistent mutex state")); + } + new$1 = (new$1 & ~(2)) >> 0; + } + /* */ if (atomic.CompareAndSwapInt32((m.$ptr_state || (m.$ptr_state = new ptrType$4(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$4(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, m))), old, new$1)) { */ case 5: + if ((old & 1) === 0) { + /* break; */ $s = 2; continue; + } + $r = runtime_Semacquire((m.$ptr_sema || (m.$ptr_sema = new ptrType$1(function() { return this.$target.sema; }, function($v) { this.$target.sema = $v; }, m)))); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + awoke = true; + iter = 0; + /* } */ case 6: + /* } */ $s = 1; continue; case 2: + if (false) { + race.Acquire(m); + } + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Mutex.ptr.prototype.Lock }; } $f.$ptr = $ptr; $f.awoke = awoke; $f.iter = iter; $f.m = m; $f.new$1 = new$1; $f.old = old; $f.$s = $s; $f.$r = $r; return $f; + }; + Mutex.prototype.Lock = function() { return this.$val.Lock(); }; + Mutex.ptr.prototype.Unlock = function() { + var $ptr, m, new$1, old, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; 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) { + race.Release(m); + } + new$1 = atomic.AddInt32((m.$ptr_state || (m.$ptr_state = new ptrType$4(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, m))), -1); + if ((((new$1 + 1 >> 0)) & 1) === 0) { + $panic(new $String("sync: unlock of unlocked mutex")); + } + old = new$1; + /* while (true) { */ case 1: + if (((old >> 2 >> 0) === 0) || !(((old & 3) === 0))) { + return; + } + new$1 = ((old - 4 >> 0)) | 2; + /* */ if (atomic.CompareAndSwapInt32((m.$ptr_state || (m.$ptr_state = new ptrType$4(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, m))), old, new$1)) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (atomic.CompareAndSwapInt32((m.$ptr_state || (m.$ptr_state = new ptrType$4(function() { return this.$target.state; }, function($v) { this.$target.state = $v; }, m))), old, new$1)) { */ case 3: + $r = runtime_Semrelease((m.$ptr_sema || (m.$ptr_sema = new ptrType$1(function() { return this.$target.sema; }, function($v) { this.$target.sema = $v; }, m)))); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + return; + /* } */ case 4: + old = m.state; + /* } */ $s = 1; continue; case 2: + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Mutex.ptr.prototype.Unlock }; } $f.$ptr = $ptr; $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(); }; + Once.ptr.prototype.Do = function(f) { + var $ptr, f, o, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; 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 = this; + if (atomic.LoadUint32((o.$ptr_done || (o.$ptr_done = new ptrType$1(function() { return this.$target.done; }, function($v) { this.$target.done = $v; }, o)))) === 1) { + return; + } + $r = o.m.Lock(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $deferred.push([$methodVal(o.m, "Unlock"), []]); + /* */ if (o.done === 0) { $s = 2; continue; } + /* */ $s = 3; continue; + /* if (o.done === 0) { */ case 2: + $deferred.push([atomic.StoreUint32, [(o.$ptr_done || (o.$ptr_done = new ptrType$1(function() { return this.$target.done; }, function($v) { this.$target.done = $v; }, o))), 1]]); + $r = f(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 3: + /* */ $s = -1; case -1: } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: Once.ptr.prototype.Do }; } $f.$ptr = $ptr; $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); }; + poolCleanup = function() { + var $ptr, _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") : _ref.$array[_ref.$offset + _i]); + ((i < 0 || i >= allPools.$length) ? $throwRuntimeError("index out of range") : 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.private$0 = $ifaceNil; + _ref$1 = l.shared; + _i$1 = 0; + while (true) { + if (!(_i$1 < _ref$1.$length)) { break; } + j = _i$1; + (x = l.shared, ((j < 0 || j >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + j] = $ifaceNil)); + _i$1++; + } + l.shared = sliceType$3.nil; + i$1 = i$1 + (1) >> 0; + } + p.local = 0; + p.localSize = 0; + _i++; + } + allPools = new sliceType([]); + }; + init = function() { + var $ptr; + runtime_registerPoolCleanup(poolCleanup); + }; + indexLocal = function(l, i) { + var $ptr, i, l, x; + return (x = l, (x.nilCheck, ((i < 0 || i >= x.length) ? $throwRuntimeError("index out of range") : x[i]))); + }; + init$1 = function() { + var $ptr, s; + s = new syncSema.ptr(0, 0, 0); + runtime_Syncsemcheck(12); + }; + runtime_doSpin = function() { + $throwRuntimeError("native function not implemented: sync.runtime_doSpin"); + }; + RWMutex.ptr.prototype.RLock = function() { + var $ptr, rw, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; rw = $f.rw; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + rw = this; + if (false) { + race.Disable(); + } + /* */ if (atomic.AddInt32((rw.$ptr_readerCount || (rw.$ptr_readerCount = new ptrType$4(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$4(function() { return this.$target.readerCount; }, function($v) { this.$target.readerCount = $v; }, rw))), 1) < 0) { */ case 1: + $r = runtime_Semacquire((rw.$ptr_readerSem || (rw.$ptr_readerSem = new ptrType$1(function() { return this.$target.readerSem; }, function($v) { this.$target.readerSem = $v; }, rw)))); /* */ $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; case -1: } return; } if ($f === undefined) { $f = { $blk: RWMutex.ptr.prototype.RLock }; } $f.$ptr = $ptr; $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 $ptr, r, rw, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; r = $f.r; rw = $f.rw; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + rw = this; + if (false) { + 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$4(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(); + $panic(new $String("sync: RUnlock of unlocked RWMutex")); + } + /* */ if (atomic.AddInt32((rw.$ptr_readerWait || (rw.$ptr_readerWait = new ptrType$4(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$4(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)))); /* */ $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; case -1: } return; } if ($f === undefined) { $f = { $blk: RWMutex.ptr.prototype.RUnlock }; } $f.$ptr = $ptr; $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 $ptr, r, rw, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; r = $f.r; rw = $f.rw; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + rw = this; + if (false) { + 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$4(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$4(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$4(function() { return this.$target.readerWait; }, function($v) { this.$target.readerWait = $v; }, rw))), r) === 0))) { */ case 2: + $r = runtime_Semacquire((rw.$ptr_writerSem || (rw.$ptr_writerSem = new ptrType$1(function() { return this.$target.writerSem; }, function($v) { this.$target.writerSem = $v; }, rw)))); /* */ $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; case -1: } return; } if ($f === undefined) { $f = { $blk: RWMutex.ptr.prototype.Lock }; } $f.$ptr = $ptr; $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 $ptr, i, r, rw, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; 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) { + race.Release((rw.$ptr_readerSem || (rw.$ptr_readerSem = new ptrType$1(function() { return this.$target.readerSem; }, function($v) { this.$target.readerSem = $v; }, rw)))); + race.Release((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$4(function() { return this.$target.readerCount; }, function($v) { this.$target.readerCount = $v; }, rw))), 1073741824); + if (r >= 1073741824) { + race.Enable(); + $panic(new $String("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)))); /* */ $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; case -1: } return; } if ($f === undefined) { $f = { $blk: RWMutex.ptr.prototype.Unlock }; } $f.$ptr = $ptr; $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 $ptr, rw; + rw = this; + return $pointerOfStructConversion(rw, ptrType$7); + }; + RWMutex.prototype.RLocker = function() { return this.$val.RLocker(); }; + rlocker.ptr.prototype.Lock = function() { + var $ptr, r, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; r = $f.r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + r = this; + $r = $pointerOfStructConversion(r, ptrType$8).RLock(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: rlocker.ptr.prototype.Lock }; } $f.$ptr = $ptr; $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 $ptr, r, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; r = $f.r; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + r = this; + $r = $pointerOfStructConversion(r, ptrType$8).RUnlock(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: rlocker.ptr.prototype.Unlock }; } $f.$ptr = $ptr; $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$6], false)}, {prop: "pinSlow", name: "pinSlow", pkg: "sync", typ: $funcType([], [ptrType$6], false)}]; + ptrType$12.methods = [{prop: "Lock", name: "Lock", pkg: "", typ: $funcType([], [], false)}, {prop: "Unlock", name: "Unlock", pkg: "", typ: $funcType([], [], false)}]; + ptrType$13.methods = [{prop: "Do", name: "Do", pkg: "", typ: $funcType([funcType$1], [], false)}]; + ptrType$8.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$7.methods = [{prop: "Lock", name: "Lock", pkg: "", typ: $funcType([], [], false)}, {prop: "Unlock", name: "Unlock", pkg: "", typ: $funcType([], [], false)}]; + Pool.init([{prop: "local", name: "local", pkg: "sync", typ: $UnsafePointer, tag: ""}, {prop: "localSize", name: "localSize", pkg: "sync", typ: $Uintptr, tag: ""}, {prop: "store", name: "store", pkg: "sync", typ: sliceType$3, tag: ""}, {prop: "New", name: "New", pkg: "", typ: funcType, tag: ""}]); + Mutex.init([{prop: "state", name: "state", pkg: "sync", typ: $Int32, tag: ""}, {prop: "sema", name: "sema", pkg: "sync", typ: $Uint32, tag: ""}]); + Locker.init([{prop: "Lock", name: "Lock", pkg: "", typ: $funcType([], [], false)}, {prop: "Unlock", name: "Unlock", pkg: "", typ: $funcType([], [], false)}]); + Once.init([{prop: "m", name: "m", pkg: "sync", typ: Mutex, tag: ""}, {prop: "done", name: "done", pkg: "sync", typ: $Uint32, tag: ""}]); + poolLocal.init([{prop: "private$0", name: "private", pkg: "sync", typ: $emptyInterface, tag: ""}, {prop: "shared", name: "shared", pkg: "sync", typ: sliceType$3, tag: ""}, {prop: "Mutex", name: "", pkg: "", typ: Mutex, tag: ""}, {prop: "pad", name: "pad", pkg: "sync", typ: arrayType$1, tag: ""}]); + syncSema.init([{prop: "lock", name: "lock", pkg: "sync", typ: $Uintptr, tag: ""}, {prop: "head", name: "head", pkg: "sync", typ: $UnsafePointer, tag: ""}, {prop: "tail", name: "tail", pkg: "sync", typ: $UnsafePointer, tag: ""}]); + RWMutex.init([{prop: "w", name: "w", pkg: "sync", typ: Mutex, tag: ""}, {prop: "writerSem", name: "writerSem", pkg: "sync", typ: $Uint32, tag: ""}, {prop: "readerSem", name: "readerSem", pkg: "sync", typ: $Uint32, tag: ""}, {prop: "readerCount", name: "readerCount", pkg: "sync", typ: $Int32, tag: ""}, {prop: "readerWait", name: "readerWait", pkg: "sync", typ: $Int32, tag: ""}]); + rlocker.init([{prop: "w", name: "w", pkg: "sync", typ: Mutex, tag: ""}, {prop: "writerSem", name: "writerSem", pkg: "sync", typ: $Uint32, tag: ""}, {prop: "readerSem", name: "readerSem", pkg: "sync", typ: $Uint32, tag: ""}, {prop: "readerCount", name: "readerCount", pkg: "sync", typ: $Int32, tag: ""}, {prop: "readerWait", name: "readerWait", pkg: "sync", 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 = race.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = runtime.$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; } + allPools = sliceType.nil; + semWaiters = {}; + 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, Reader, Writer, RuneReader, sliceType, errWhence, errOffset; + errors = $packages["errors"]; + sync = $packages["sync"]; + Reader = $pkg.Reader = $newType(8, $kindInterface, "io.Reader", "Reader", "io", null); + Writer = $pkg.Writer = $newType(8, $kindInterface, "io.Writer", "Writer", "io", null); + RuneReader = $pkg.RuneReader = $newType(8, $kindInterface, "io.RuneReader", "RuneReader", "io", null); + sliceType = $sliceType($Uint8); + 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)}]); + RuneReader.init([{prop: "ReadRune", name: "ReadRune", pkg: "", typ: $funcType([], [$Int32, $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; } + $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", "Hash", "hash", 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"] = (function() { + var $pkg = {}, $init, js, arrayType, arrayType$1, arrayType$2, structType, arrayType$3, math, zero, posInf, negInf, nan, buf, pow10tab, Inf, IsInf, IsNaN, NaN, init, Float32bits, Float32frombits, Float64bits, Float64frombits, init$1; + js = $packages["github.com/gopherjs/gopherjs/js"]; + arrayType = $arrayType($Uint32, 2); + arrayType$1 = $arrayType($Float32, 2); + arrayType$2 = $arrayType($Float64, 1); + structType = $structType([{prop: "uint32array", name: "uint32array", pkg: "math", typ: arrayType, tag: ""}, {prop: "float32array", name: "float32array", pkg: "math", typ: arrayType$1, tag: ""}, {prop: "float64array", name: "float64array", pkg: "math", typ: arrayType$2, tag: ""}]); + arrayType$3 = $arrayType($Float64, 70); + Inf = function(sign) { + var $ptr, sign; + if (sign >= 0) { + return posInf; + } else { + return negInf; + } + }; + $pkg.Inf = Inf; + IsInf = function(f, sign) { + var $ptr, f, sign; + if (f === posInf) { + return sign >= 0; + } + if (f === negInf) { + return sign <= 0; + } + return false; + }; + $pkg.IsInf = IsInf; + IsNaN = function(f) { + var $ptr, f, is; + is = false; + is = !((f === f)); + return is; + }; + $pkg.IsNaN = IsNaN; + NaN = function() { + var $ptr; + return nan; + }; + $pkg.NaN = NaN; + init = function() { + var $ptr, 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 $ptr, f; + buf.float32array[0] = f; + return buf.uint32array[0]; + }; + $pkg.Float32bits = Float32bits; + Float32frombits = function(b) { + var $ptr, b; + buf.uint32array[0] = b; + return buf.float32array[0]; + }; + $pkg.Float32frombits = Float32frombits; + Float64bits = function(f) { + var $ptr, 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 $ptr, b; + buf.uint32array[0] = (b.$low >>> 0); + buf.uint32array[1] = ($shiftRightUint64(b, 32).$low >>> 0); + return buf.float64array[0]; + }; + $pkg.Float64frombits = Float64frombits; + init$1 = function() { + var $ptr, _q, i, m, x; + pow10tab[0] = 1; + pow10tab[1] = 10; + i = 2; + while (true) { + if (!(i < 70)) { break; } + m = (_q = i / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")); + ((i < 0 || i >= pow10tab.length) ? $throwRuntimeError("index out of range") : pow10tab[i] = ((m < 0 || m >= pow10tab.length) ? $throwRuntimeError("index out of range") : pow10tab[m]) * (x = i - m >> 0, ((x < 0 || x >= pow10tab.length) ? $throwRuntimeError("index out of range") : pow10tab[x]))); + i = i + (1) >> 0; + } + }; + $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; } + buf = new structType.ptr(arrayType.zero(), arrayType$1.zero(), arrayType$2.zero()); + pow10tab = arrayType$3.zero(); + math = $global.Math; + zero = 0; + posInf = 1 / zero; + negInf = -1 / zero; + nan = 0 / zero; + init(); + init$1(); + /* */ } 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, RuneLen, EncodeRune, RuneCount, RuneCountInString, RuneStart; + acceptRange = $pkg.acceptRange = $newType(0, $kindStruct, "utf8.acceptRange", "acceptRange", "unicode/utf8", 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 $ptr, _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") : p.$array[p.$offset + 0]); + x = ((p0 < 0 || p0 >= first.length) ? $throwRuntimeError("index out of range") : first[p0]); + if (x >= 240) { + mask = ((x >> 0) << 31 >> 0) >> 31 >> 0; + _tmp$2 = ((((0 >= p.$length ? $throwRuntimeError("index out of range") : 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") : 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") : 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") : 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") : 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 $ptr, _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") : 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") : 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 $ptr, _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") : 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") : 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; + RuneLen = function(r) { + var $ptr, 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 $ptr, i, p, r; + i = (r >>> 0); + if (i <= 127) { + (0 >= p.$length ? $throwRuntimeError("index out of range") : p.$array[p.$offset + 0] = (r << 24 >>> 24)); + return 1; + } else if (i <= 2047) { + (0 >= p.$length ? $throwRuntimeError("index out of range") : p.$array[p.$offset + 0] = ((192 | ((r >> 6 >> 0) << 24 >>> 24)) >>> 0)); + (1 >= p.$length ? $throwRuntimeError("index out of range") : p.$array[p.$offset + 1] = ((128 | (((r << 24 >>> 24) & 63) >>> 0)) >>> 0)); + return 2; + } else if ((i > 1114111) || (55296 <= i && i <= 57343)) { + r = 65533; + (0 >= p.$length ? $throwRuntimeError("index out of range") : p.$array[p.$offset + 0] = ((224 | ((r >> 12 >> 0) << 24 >>> 24)) >>> 0)); + (1 >= p.$length ? $throwRuntimeError("index out of range") : p.$array[p.$offset + 1] = ((128 | ((((r >> 6 >> 0) << 24 >>> 24) & 63) >>> 0)) >>> 0)); + (2 >= p.$length ? $throwRuntimeError("index out of range") : p.$array[p.$offset + 2] = ((128 | (((r << 24 >>> 24) & 63) >>> 0)) >>> 0)); + return 3; + } else if (i <= 65535) { + (0 >= p.$length ? $throwRuntimeError("index out of range") : p.$array[p.$offset + 0] = ((224 | ((r >> 12 >> 0) << 24 >>> 24)) >>> 0)); + (1 >= p.$length ? $throwRuntimeError("index out of range") : p.$array[p.$offset + 1] = ((128 | ((((r >> 6 >> 0) << 24 >>> 24) & 63) >>> 0)) >>> 0)); + (2 >= p.$length ? $throwRuntimeError("index out of range") : p.$array[p.$offset + 2] = ((128 | (((r << 24 >>> 24) & 63) >>> 0)) >>> 0)); + return 3; + } else { + (0 >= p.$length ? $throwRuntimeError("index out of range") : p.$array[p.$offset + 0] = ((240 | ((r >> 18 >> 0) << 24 >>> 24)) >>> 0)); + (1 >= p.$length ? $throwRuntimeError("index out of range") : p.$array[p.$offset + 1] = ((128 | ((((r >> 12 >> 0) << 24 >>> 24) & 63) >>> 0)) >>> 0)); + (2 >= p.$length ? $throwRuntimeError("index out of range") : p.$array[p.$offset + 2] = ((128 | ((((r >> 6 >> 0) << 24 >>> 24) & 63) >>> 0)) >>> 0)); + (3 >= p.$length ? $throwRuntimeError("index out of range") : p.$array[p.$offset + 3] = ((128 | (((r << 24 >>> 24) & 63) >>> 0)) >>> 0)); + return 4; + } + }; + $pkg.EncodeRune = EncodeRune; + RuneCount = function(p) { + var $ptr, 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") : p.$array[p.$offset + i]); + if (c < 128) { + i = i + (1) >> 0; + continue; + } + x = ((c < 0 || c >= first.length) ? $throwRuntimeError("index out of range") : 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") : acceptRanges[x$1])), acceptRange); + c$1 = (x$2 = i + 1 >> 0, ((x$2 < 0 || x$2 >= p.$length) ? $throwRuntimeError("index out of range") : 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") : 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") : 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 $ptr, 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") : 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") : 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 $ptr, b; + return !((((b & 192) >>> 0) === 128)); + }; + $pkg.RuneStart = RuneStart; + acceptRange.init([{prop: "lo", name: "lo", pkg: "unicode/utf8", typ: $Uint8, tag: ""}, {prop: "hi", name: "hi", pkg: "unicode/utf8", 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, math, utf8, NumError, decimal, leftCheat, extFloat, floatInfo, decimalSlice, sliceType, sliceType$1, sliceType$2, sliceType$3, sliceType$4, sliceType$5, arrayType, ptrType, sliceType$6, 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, shifts, ParseBool, equalIgnoreCase, special, readFloat, atof64exact, atof32exact, atof32, atof64, ParseFloat, syntaxError, rangeError, ParseUint, ParseInt, digitZero, trim, rightShift, prefixIsLessThan, leftShift, shouldRoundUp, frexp10Many, adjustLastDigitFixed, adjustLastDigit, FormatFloat, AppendFloat, genericFtoa, bigFtoa, formatDigits, roundShortest, fmtE, fmtF, fmtB, min, max, FormatInt, Itoa, AppendInt, AppendUint, formatBits, quoteWith, Quote, QuoteToASCII, QuoteRune, AppendQuoteRune, QuoteRuneToASCII, AppendQuoteRuneToASCII, CanBackquote, unhex, UnquoteChar, Unquote, contains, bsearch16, bsearch32, IsPrint, isInGraphicList; + errors = $packages["errors"]; + math = $packages["math"]; + utf8 = $packages["unicode/utf8"]; + NumError = $pkg.NumError = $newType(0, $kindStruct, "strconv.NumError", "NumError", "strconv", 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", "decimal", "strconv", 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", "leftCheat", "strconv", 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", "extFloat", "strconv", 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", "floatInfo", "strconv", 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", "decimalSlice", "strconv", 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); + ptrType = $ptrType(NumError); + sliceType$6 = $sliceType($Uint8); + 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); + ParseBool = function(str) { + var $ptr, _1, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, err, str, value; + value = false; + err = $ifaceNil; + _1 = str; + if (_1 === ("1") || _1 === ("t") || _1 === ("T") || _1 === ("true") || _1 === ("TRUE") || _1 === ("True")) { + _tmp = true; + _tmp$1 = $ifaceNil; + value = _tmp; + err = _tmp$1; + return [value, err]; + } else if (_1 === ("0") || _1 === ("f") || _1 === ("F") || _1 === ("false") || _1 === ("FALSE") || _1 === ("False")) { + _tmp$2 = false; + _tmp$3 = $ifaceNil; + value = _tmp$2; + err = _tmp$3; + return [value, err]; + } + _tmp$4 = false; + _tmp$5 = syntaxError("ParseBool", str); + value = _tmp$4; + err = _tmp$5; + return [value, err]; + }; + $pkg.ParseBool = ParseBool; + equalIgnoreCase = function(s1, s2) { + var $ptr, 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 $ptr, _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 $ptr, 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") : 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 $ptr, _2, 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); + _2 = true; + if (_2 === ((c === 46))) { + if (sawdot) { + return [mantissa, exp, neg, trunc, ok]; + } + sawdot = true; + dp = nd; + i = i + (1) >> 0; + continue; + } else if (_2 === (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]; + } + exp = dp - ndMant >> 0; + ok = true; + return [mantissa, exp, neg, trunc, ok]; + }; + decimal.ptr.prototype.floatBits = function(flt) { + var $ptr, _tmp, _tmp$1, b, bits, 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") : 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") : 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 = (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 = (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.$high | x$7.$high, (bits.$low | x$7.$low) >>> 0)); + if (d.neg) { + bits = (x$8 = $shiftLeft64($shiftLeft64(new $Uint64(0, 1), flt.mantbits), flt.expbits), new $Uint64(bits.$high | x$8.$high, (bits.$low | x$8.$low) >>> 0)); + } + _tmp = bits; + _tmp$1 = overflow; + b = _tmp; + overflow = _tmp$1; + return [b, overflow]; + /* */ } return; } + }; + decimal.prototype.floatBits = function(flt) { return this.$val.floatBits(flt); }; + atof64exact = function(mantissa, exp, neg) { + var $ptr, _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") : 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") : 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") : 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 $ptr, _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") : 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") : 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") : 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 $ptr, _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 $ptr, _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 $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, _tuple$1, bitSize, err, err1, err1$1, f, f1, f1$1, s; + f = 0; + err = $ifaceNil; + if (bitSize === 32) { + _tuple = atof32(s); + f1 = _tuple[0]; + err1 = _tuple[1]; + _tmp = f1; + _tmp$1 = err1; + f = _tmp; + err = _tmp$1; + return [f, err]; + } + _tuple$1 = atof64(s); + f1$1 = _tuple$1[0]; + err1$1 = _tuple$1[1]; + _tmp$2 = f1$1; + _tmp$3 = err1$1; + f = _tmp$2; + err = _tmp$3; + return [f, err]; + }; + $pkg.ParseFloat = ParseFloat; + NumError.ptr.prototype.Error = function() { + var $ptr, _r, e, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _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 = 2; case 2: + return "strconv." + e.Func + ": " + "parsing " + Quote(e.Num) + ": " + _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: NumError.ptr.prototype.Error }; } $f.$ptr = $ptr; $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 $ptr, fn, str; + return new NumError.ptr(fn, str, $pkg.ErrSyntax); + }; + rangeError = function(fn, str) { + var $ptr, fn, str; + return new NumError.ptr(fn, str, $pkg.ErrRange); + }; + ParseUint = function(s, base, bitSize) { + var $ptr, _1, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, base, bitSize, cutoff, d, err, i, maxVal, n, n1, s, v, x, x$1, x$2, $s; + /* */ $s = 0; s: while (true) { switch ($s) { case 0: + n = new $Uint64(0, 0); + err = $ifaceNil; + _tmp = new $Uint64(0, 0); + _tmp$1 = new $Uint64(0, 0); + cutoff = _tmp; + maxVal = _tmp$1; + if (bitSize === 0) { + bitSize = 32; + } + i = 0; + /* */ if (s.length < 1) { $s = 2; continue; } + /* */ if (2 <= base && base <= 36) { $s = 3; continue; } + /* */ if ((base === 0)) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (s.length < 1) { */ case 2: + err = $pkg.ErrSyntax; + /* goto Error */ $s = 7; continue; + $s = 6; continue; + /* } else if (2 <= base && base <= 36) { */ case 3: + $s = 6; continue; + /* } else if ((base === 0)) { */ case 4: + /* */ if ((s.charCodeAt(0) === 48) && s.length > 1 && ((s.charCodeAt(1) === 120) || (s.charCodeAt(1) === 88))) { $s = 9; continue; } + /* */ if ((s.charCodeAt(0) === 48)) { $s = 10; continue; } + /* */ $s = 11; continue; + /* if ((s.charCodeAt(0) === 48) && s.length > 1 && ((s.charCodeAt(1) === 120) || (s.charCodeAt(1) === 88))) { */ case 9: + /* */ if (s.length < 3) { $s = 13; continue; } + /* */ $s = 14; continue; + /* if (s.length < 3) { */ case 13: + err = $pkg.ErrSyntax; + /* goto Error */ $s = 7; continue; + /* } */ case 14: + base = 16; + i = 2; + $s = 12; continue; + /* } else if ((s.charCodeAt(0) === 48)) { */ case 10: + base = 8; + i = 1; + $s = 12; continue; + /* } else { */ case 11: + base = 10; + /* } */ case 12: + case 8: + $s = 6; continue; + /* } else { */ case 5: + err = errors.New("invalid base " + Itoa(base)); + /* goto Error */ $s = 7; continue; + /* } */ case 6: + case 1: + _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)); + /* while (true) { */ case 15: + /* if (!(i < s.length)) { break; } */ if(!(i < s.length)) { $s = 16; continue; } + v = 0; + d = s.charCodeAt(i); + /* */ if (48 <= d && d <= 57) { $s = 18; continue; } + /* */ if (97 <= d && d <= 122) { $s = 19; continue; } + /* */ if (65 <= d && d <= 90) { $s = 20; continue; } + /* */ $s = 21; continue; + /* if (48 <= d && d <= 57) { */ case 18: + v = d - 48 << 24 >>> 24; + $s = 22; continue; + /* } else if (97 <= d && d <= 122) { */ case 19: + v = (d - 97 << 24 >>> 24) + 10 << 24 >>> 24; + $s = 22; continue; + /* } else if (65 <= d && d <= 90) { */ case 20: + v = (d - 65 << 24 >>> 24) + 10 << 24 >>> 24; + $s = 22; continue; + /* } else { */ case 21: + n = new $Uint64(0, 0); + err = $pkg.ErrSyntax; + /* goto Error */ $s = 7; continue; + /* } */ case 22: + case 17: + /* */ if (v >= (base << 24 >>> 24)) { $s = 23; continue; } + /* */ $s = 24; continue; + /* if (v >= (base << 24 >>> 24)) { */ case 23: + n = new $Uint64(0, 0); + err = $pkg.ErrSyntax; + /* goto Error */ $s = 7; continue; + /* } */ case 24: + /* */ if ((n.$high > cutoff.$high || (n.$high === cutoff.$high && n.$low >= cutoff.$low))) { $s = 25; continue; } + /* */ $s = 26; continue; + /* if ((n.$high > cutoff.$high || (n.$high === cutoff.$high && n.$low >= cutoff.$low))) { */ case 25: + n = new $Uint64(4294967295, 4294967295); + err = $pkg.ErrRange; + /* goto Error */ $s = 7; continue; + /* } */ case 26: + n = $mul64(n, (new $Uint64(0, base))); + n1 = (x$2 = new $Uint64(0, v), 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))) { $s = 27; continue; } + /* */ $s = 28; continue; + /* 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))) { */ case 27: + n = new $Uint64(4294967295, 4294967295); + err = $pkg.ErrRange; + /* goto Error */ $s = 7; continue; + /* } */ case 28: + n = n1; + i = i + (1) >> 0; + /* } */ $s = 15; continue; case 16: + _tmp$2 = n; + _tmp$3 = $ifaceNil; + n = _tmp$2; + err = _tmp$3; + return [n, err]; + /* Error: */ case 7: + _tmp$4 = n; + _tmp$5 = new NumError.ptr("ParseUint", s, err); + n = _tmp$4; + err = _tmp$5; + return [n, err]; + /* */ $s = -1; case -1: } return; } + }; + $pkg.ParseUint = ParseUint; + ParseInt = function(s, base, bitSize) { + var $ptr, _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 (bitSize === 0) { + bitSize = 32; + } + 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 = s.substring(1); + } else if (s.charCodeAt(0) === 45) { + neg = true; + s = s.substring(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]; + } + 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 $ptr, 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") : buf.$array[buf.$offset + w] = 48); + w = w + (1) >> 0; + ((w < 0 || w >= buf.$length) ? $throwRuntimeError("index out of range") : 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") : 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 $ptr, _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") : dst.$array[dst.$offset + i] = 48); + _i++; + } + return dst.$length; + }; + trim = function(a) { + var $ptr, 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") : 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 $ptr, 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") : 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") : x$1[x$2] = ((n < 0 || n >= buf.length) ? $throwRuntimeError("index out of range") : 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 $ptr, a, c, c$1, dig, dig$1, k, n, r, w, x, x$1, x$2, x$3, y, y$1, y$2, y$3, y$4, y$5; + 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") : x[r])) >>> 0); + n = ((n * 10 >>> 0) + c >>> 0) - 48 >>> 0; + r = r + (1) >> 0; + } + a.dp = a.dp - ((r - 1 >> 0)) >> 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") : x$1[r])) >>> 0); + dig = (y$2 = k, y$2 < 32 ? (n >>> y$2) : 0) >>> 0; + n = n - (((y$3 = k, y$3 < 32 ? (dig << y$3) : 0) >>> 0)) >>> 0; + (x$2 = a.d, ((w < 0 || w >= x$2.length) ? $throwRuntimeError("index out of range") : 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 - (((y$5 = k, y$5 < 32 ? (dig$1 << y$5) : 0) >>> 0)) >>> 0; + if (w < 800) { + (x$3 = a.d, ((w < 0 || w >= x$3.length) ? $throwRuntimeError("index out of range") : 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 $ptr, 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") : b.$array[b.$offset + i]) === s.charCodeAt(i)))) { + return ((i < 0 || i >= b.$length) ? $throwRuntimeError("index out of range") : b.$array[b.$offset + i]) < s.charCodeAt(i); + } + i = i + (1) >> 0; + } + return false; + }; + leftShift = function(a, k) { + var $ptr, _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") : 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") : 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") : 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") : 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") : 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 $ptr, 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 $ptr, _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") : 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") : 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") : x$3[nd])) >= 53; + }; + decimal.ptr.prototype.Round = function(nd) { + var $ptr, 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 $ptr, 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 $ptr, 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") : x[i])); + if (c < 57) { + (x$2 = a.d, ((i < 0 || i >= x$2.length) ? $throwRuntimeError("index out of range") : x$2[i] = ((x$1 = a.d, ((i < 0 || i >= x$1.length) ? $throwRuntimeError("index out of range") : 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 $ptr, 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") : 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 $ptr, bits, 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 = 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 = (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 = (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.$high | x$9.$high, (bits.$low | x$9.$low) >>> 0)); + if (f.neg) { + bits = (x$10 = $shiftLeft64(new $Uint64(0, 1), ((flt.mantbits + flt.expbits >>> 0))), new $Uint64(bits.$high | x$10.$high, (bits.$low | x$10.$low) >>> 0)); + } + return [bits, overflow]; + }; + extFloat.prototype.floatBits = function(flt) { return this.$val.floatBits(flt); }; + extFloat.ptr.prototype.AssignComputeBounds = function(mant, exp, neg, flt) { + var $ptr, _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 $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, exp, f, mant, shift, x, x$1, x$2, x$3, x$4, x$5; + shift = 0; + f = this; + _tmp = f.mant; + _tmp$1 = f.exp; + mant = _tmp; + exp = _tmp$1; + if ((mant.$high === 0 && mant.$low === 0)) { + shift = 0; + return shift; + } + if ((x = $shiftRightUint64(mant, 32), (x.$high === 0 && x.$low === 0))) { + mant = $shiftLeft64(mant, (32)); + exp = exp - (32) >> 0; + } + if ((x$1 = $shiftRightUint64(mant, 48), (x$1.$high === 0 && x$1.$low === 0))) { + mant = $shiftLeft64(mant, (16)); + exp = exp - (16) >> 0; + } + if ((x$2 = $shiftRightUint64(mant, 56), (x$2.$high === 0 && x$2.$low === 0))) { + mant = $shiftLeft64(mant, (8)); + exp = exp - (8) >> 0; + } + if ((x$3 = $shiftRightUint64(mant, 60), (x$3.$high === 0 && x$3.$low === 0))) { + mant = $shiftLeft64(mant, (4)); + exp = exp - (4) >> 0; + } + if ((x$4 = $shiftRightUint64(mant, 62), (x$4.$high === 0 && x$4.$low === 0))) { + mant = $shiftLeft64(mant, (2)); + exp = exp - (2) >> 0; + } + if ((x$5 = $shiftRightUint64(mant, 63), (x$5.$high === 0 && x$5.$low === 0))) { + mant = $shiftLeft64(mant, (1)); + exp = exp - (1) >> 0; + } + shift = ((f.exp - exp >> 0) >>> 0); + _tmp$2 = mant; + _tmp$3 = exp; + f.mant = _tmp$2; + f.exp = _tmp$3; + return shift; + }; + extFloat.prototype.Normalize = function() { return this.$val.Normalize(); }; + extFloat.ptr.prototype.Multiply = function(g) { + var $ptr, _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; + g = $clone(g, extFloat); + 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 $ptr, _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") : 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") : uint64pow10[adjExp]))); + f.Normalize(); + } else { + f.Normalize(); + f.Multiply(((adjExp < 0 || adjExp >= smallPowersOfTen.length) ? $throwRuntimeError("index out of range") : smallPowersOfTen[adjExp])); + errors$1 = errors$1 + (4) >> 0; + } + f.Multiply(((i < 0 || i >= powersOfTen.length) ? $throwRuntimeError("index out of range") : powersOfTen[i])); + 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 $ptr, _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") : 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(((i < 0 || i >= powersOfTen.length) ? $throwRuntimeError("index out of range") : powersOfTen[i])); + _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 $ptr, _tuple, a, b, c, exp10, i; + exp10 = 0; + _tuple = c.frexp10(); + exp10 = _tuple[0]; + i = _tuple[1]; + a.Multiply(((i < 0 || i >= powersOfTen.length) ? $throwRuntimeError("index out of range") : powersOfTen[i])); + b.Multiply(((i < 0 || i >= powersOfTen.length) ? $throwRuntimeError("index out of range") : powersOfTen[i])); + return exp10; + }; + extFloat.ptr.prototype.FixedDecimal = function(d, n) { + var $CE$B5, $ptr, _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") : 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") : 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") : x$5.$array[x$5.$offset + x$6] = ((i$1 < 0 || i$1 >= buf.length) ? $throwRuntimeError("index out of range") : 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") : 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") : 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, $ptr, 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") : 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") : 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") : x$10.$array[x$10.$offset + i] = ((x$9 = d.d, ((i < 0 || i >= x$9.$length) ? $throwRuntimeError("index out of range") : x$9.$array[x$9.$offset + i])) + (1) << 24 >>> 24))); + } + return true; + } + return false; + }; + extFloat.ptr.prototype.ShortestDecimal = function(d, lower, upper) { + var $ptr, _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") : 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") : 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") : 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") : 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") : 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") : 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") : 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 $ptr, _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") : x$5.$array[x$5.$offset + _index] = ((x$4 = d.d, ((_index < 0 || _index >= x$4.$length) ? $throwRuntimeError("index out of range") : 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") : x$12.$array[x$12.$offset + 0])) === 48)) { + d.nd = 0; + d.dp = 0; + } + return true; + }; + FormatFloat = function(f, fmt, prec, bitSize) { + var $ptr, 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 $ptr, bitSize, dst, f, fmt, prec; + return genericFtoa(dst, f, fmt, prec, bitSize); + }; + $pkg.AppendFloat = AppendFloat; + genericFtoa = function(dst, val, fmt, prec, bitSize) { + var $ptr, _1, _2, _3, _4, _tuple, bitSize, bits, 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 = new $Uint64(0, 0); + flt = ptrType$1.nil; + _1 = bitSize; + if (_1 === (32)) { + bits = new $Uint64(0, math.Float32bits($fround(val))); + flt = float32info; + } else if (_1 === (64)) { + bits = math.Float64bits(val); + flt = float64info; + } else { + $panic(new $String("strconv: illegal AppendFloat/FormatFloat bitSize")); + } + neg = !((x = $shiftRightUint64(bits, ((flt.expbits + flt.mantbits >>> 0))), (x.$high === 0 && x.$low === 0))); + exp = ($shiftRightUint64(bits, 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.$high & x$1.$high, (bits.$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, digs, prec, fmt); + }; + bigFtoa = function(dst, prec, fmt, neg, mant, exp, flt) { + var $ptr, _5, _6, 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)); + _5 = fmt; + if ((_5 === (101)) || (_5 === (69))) { + prec = digs.nd - 1 >> 0; + } else if (_5 === (102)) { + prec = max(digs.nd - digs.dp >> 0, 0); + } else if ((_5 === (103)) || (_5 === (71))) { + prec = digs.nd; + } + } else { + _6 = fmt; + if ((_6 === (101)) || (_6 === (69))) { + d.Round(prec + 1 >> 0); + } else if (_6 === (102)) { + d.Round(d.dp + prec >> 0); + } else if ((_6 === (103)) || (_6 === (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, digs, prec, fmt); + }; + formatDigits = function(dst, shortest, neg, digs, prec, fmt) { + var $ptr, _7, digs, dst, eprec, exp, fmt, neg, prec, shortest; + digs = $clone(digs, decimalSlice); + _7 = fmt; + if ((_7 === (101)) || (_7 === (69))) { + return fmtE(dst, neg, digs, prec, fmt); + } else if (_7 === (102)) { + return fmtF(dst, neg, digs, prec); + } else if ((_7 === (103)) || (_7 === (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, digs, prec - 1 >> 0, (fmt + 101 << 24 >>> 24) - 103 << 24 >>> 24); + } + if (prec > digs.dp) { + prec = digs.nd; + } + return fmtF(dst, neg, digs, max(prec - digs.dp >> 0, 0)); + } + return $append(dst, 37, fmt); + }; + roundShortest = function(d, mant, exp, flt) { + var $ptr, 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") : x$5[i])); + } + m = (x$6 = d.d, ((i < 0 || i >= x$6.length) ? $throwRuntimeError("index out of range") : 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") : 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 $ptr, _q, _q$1, _q$2, _r, _r$1, _r$2, ch, d, dst, exp, fmt, i, m, neg, prec, x; + d = $clone(d, decimalSlice); + if (neg) { + dst = $append(dst, 45); + } + ch = 48; + if (!((d.nd === 0))) { + ch = (x = d.d, (0 >= x.$length ? $throwRuntimeError("index out of range") : 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 $ptr, ch, d, dst, i, j, m, neg, prec, x; + d = $clone(d, decimalSlice); + 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") : x.$array[x.$offset + j])); + } + dst = $append(dst, ch); + i = i + (1) >> 0; + } + } + return dst; + }; + fmtB = function(dst, neg, mant, exp, flt) { + var $ptr, _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 $ptr, a, b; + if (a < b) { + return a; + } + return b; + }; + max = function(a, b) { + var $ptr, a, b; + if (a > b) { + return a; + } + return b; + }; + FormatInt = function(i, base) { + var $ptr, _tuple, base, i, s; + _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 $ptr, i; + return FormatInt(new $Int64(0, i), 10); + }; + $pkg.Itoa = Itoa; + AppendInt = function(dst, i, base) { + var $ptr, _tuple, base, dst, i; + _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 $ptr, _tuple, base, dst, i; + _tuple = formatBits(dst, i, base, false, true); + dst = _tuple[0]; + return dst; + }; + $pkg.AppendUint = AppendUint; + formatBits = function(dst, u, base, neg, append_) { + var $ptr, _q, _q$1, a, append_, b, b$1, base, d, dst, i, j, m, neg, q, q$1, q$2, qs, s, s$1, u, us, us$1, x, x$1; + 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 > 4294967295)))) { 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 = 9; + while (true) { + if (!(j > 0)) { break; } + i = i - (1) >> 0; + qs = (_q = us / 10, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >>> 0 : $throwRuntimeError("integer divide by zero")); + ((i < 0 || i >= a.length) ? $throwRuntimeError("index out of range") : a[i] = (((us - ($imul(qs, 10) >>> 0) >>> 0) + 48 >>> 0) << 24 >>> 24)); + us = qs; + j = j - (1) >> 0; + } + u = q; + } + } + us$1 = (u.$low >>> 0); + while (true) { + if (!(us$1 >= 10)) { break; } + i = i - (1) >> 0; + q$1 = (_q$1 = us$1 / 10, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >>> 0 : $throwRuntimeError("integer divide by zero")); + ((i < 0 || i >= a.length) ? $throwRuntimeError("index out of range") : a[i] = (((us$1 - ($imul(q$1, 10) >>> 0) >>> 0) + 48 >>> 0) << 24 >>> 24)); + us$1 = q$1; + } + i = i - (1) >> 0; + ((i < 0 || i >= a.length) ? $throwRuntimeError("index out of range") : a[i] = ((us$1 + 48 >>> 0) << 24 >>> 24)); + } else { + s$1 = ((base < 0 || base >= shifts.length) ? $throwRuntimeError("index out of range") : shifts[base]); + if (s$1 > 0) { + b = new $Uint64(0, base); + m = (b.$low >>> 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") : a[i] = "0123456789abcdefghijklmnopqrstuvwxyz".charCodeAt((((u.$low >>> 0) & m) >>> 0))); + u = $shiftRightUint64(u, (s$1)); + } + i = i - (1) >> 0; + ((i < 0 || i >= a.length) ? $throwRuntimeError("index out of range") : 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$2 = $div64(u, b$1, false); + ((i < 0 || i >= a.length) ? $throwRuntimeError("index out of range") : a[i] = "0123456789abcdefghijklmnopqrstuvwxyz".charCodeAt(((x$1 = $mul64(q$2, b$1), new $Uint64(u.$high - x$1.$high, u.$low - x$1.$low)).$low >>> 0))); + u = q$2; + } + i = i - (1) >> 0; + ((i < 0 || i >= a.length) ? $throwRuntimeError("index out of range") : a[i] = "0123456789abcdefghijklmnopqrstuvwxyz".charCodeAt((u.$low >>> 0))); + } + } + if (neg) { + i = i - (1) >> 0; + ((i < 0 || i >= a.length) ? $throwRuntimeError("index out of range") : 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]; + }; + quoteWith = function(s, quote, ASCIIonly, graphicOnly) { + var $ptr, ASCIIonly, _1, _q, _tuple, buf, graphicOnly, n, quote, r, runeTmp, s, s$1, s$2, width; + runeTmp = arrayType$4.zero(); + buf = $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"))); + 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 = s.substring(width); + continue; + } + if ((r === (quote >> 0)) || (r === 92)) { + buf = $append(buf, 92); + buf = $append(buf, (r << 24 >>> 24)); + s = s.substring(width); + continue; + } + if (ASCIIonly) { + if (r < 128 && IsPrint(r)) { + buf = $append(buf, (r << 24 >>> 24)); + s = s.substring(width); + continue; + } + } 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)); + s = s.substring(width); + continue; + } + _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((s.charCodeAt(0) >>> 4 << 24 >>> 24))); + buf = $append(buf, "0123456789abcdef".charCodeAt(((s.charCodeAt(0) & 15) >>> 0))); + } else if (r > 1114111) { + r = 65533; + buf = $appendSlice(buf, "\\u"); + s$1 = 12; + 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; + } + } else if (r < 65536) { + buf = $appendSlice(buf, "\\u"); + s$1 = 12; + 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; + } + } else { + buf = $appendSlice(buf, "\\U"); + s$2 = 28; + while (true) { + if (!(s$2 >= 0)) { break; } + buf = $append(buf, "0123456789abcdef".charCodeAt((((r >> $min((s$2 >>> 0), 31)) >> 0) & 15))); + s$2 = s$2 - (4) >> 0; + } + } + } + s = s.substring(width); + } + buf = $append(buf, quote); + return $bytesToString(buf); + }; + Quote = function(s) { + var $ptr, s; + return quoteWith(s, 34, false, false); + }; + $pkg.Quote = Quote; + QuoteToASCII = function(s) { + var $ptr, s; + return quoteWith(s, 34, true, false); + }; + $pkg.QuoteToASCII = QuoteToASCII; + QuoteRune = function(r) { + var $ptr, r; + return quoteWith($encodeRune(r), 39, false, false); + }; + $pkg.QuoteRune = QuoteRune; + AppendQuoteRune = function(dst, r) { + var $ptr, dst, r; + return $appendSlice(dst, QuoteRune(r)); + }; + $pkg.AppendQuoteRune = AppendQuoteRune; + QuoteRuneToASCII = function(r) { + var $ptr, r; + return quoteWith($encodeRune(r), 39, true, false); + }; + $pkg.QuoteRuneToASCII = QuoteRuneToASCII; + AppendQuoteRuneToASCII = function(dst, r) { + var $ptr, dst, r; + return $appendSlice(dst, QuoteRuneToASCII(r)); + }; + $pkg.AppendQuoteRuneToASCII = AppendQuoteRuneToASCII; + CanBackquote = function(s) { + var $ptr, _tuple, r, s, wid; + while (true) { + if (!(s.length > 0)) { break; } + _tuple = utf8.DecodeRuneInString(s); + r = _tuple[0]; + wid = _tuple[1]; + s = s.substring(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 $ptr, _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 $ptr, _2, _3, _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; + 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 = s.substring(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 = s.substring(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 = s.substring(2); + switch (0) { default: + _2 = c$1; + if (_2 === (97)) { + value = 7; + } else if (_2 === (98)) { + value = 8; + } else if (_2 === (102)) { + value = 12; + } else if (_2 === (110)) { + value = 10; + } else if (_2 === (114)) { + value = 13; + } else if (_2 === (116)) { + value = 9; + } else if (_2 === (118)) { + value = 11; + } else if ((_2 === (120)) || (_2 === (117)) || (_2 === (85))) { + n = 0; + _3 = c$1; + if (_3 === (120)) { + n = 2; + } else if (_3 === (117)) { + n = 4; + } else if (_3 === (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 = s.substring(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 ((_2 === (48)) || (_2 === (49)) || (_2 === (50)) || (_2 === (51)) || (_2 === (52)) || (_2 === (53)) || (_2 === (54)) || (_2 === (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 = s.substring(2); + if (v$1 > 255) { + err = $pkg.ErrSyntax; + return [value, multibyte, tail, err]; + } + value = v$1; + } else if (_2 === (92)) { + value = 92; + } else if ((_2 === (39)) || (_2 === (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 $ptr, _4, _q, _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, buf, c, err, err$1, multibyte, n, n$1, quote, r, runeTmp, s, size, ss, t; + t = ""; + err = $ifaceNil; + n = s.length; + if (n < 2) { + _tmp = ""; + _tmp$1 = $pkg.ErrSyntax; + t = _tmp; + err = _tmp$1; + return [t, err]; + } + quote = s.charCodeAt(0); + if (!((quote === s.charCodeAt((n - 1 >> 0))))) { + _tmp$2 = ""; + _tmp$3 = $pkg.ErrSyntax; + t = _tmp$2; + err = _tmp$3; + return [t, err]; + } + s = s.substring(1, (n - 1 >> 0)); + if (quote === 96) { + if (contains(s, 96)) { + _tmp$4 = ""; + _tmp$5 = $pkg.ErrSyntax; + t = _tmp$4; + err = _tmp$5; + return [t, err]; + } + _tmp$6 = s; + _tmp$7 = $ifaceNil; + t = _tmp$6; + err = _tmp$7; + return [t, err]; + } + if (!((quote === 34)) && !((quote === 39))) { + _tmp$8 = ""; + _tmp$9 = $pkg.ErrSyntax; + t = _tmp$8; + err = _tmp$9; + return [t, err]; + } + if (contains(s, 10)) { + _tmp$10 = ""; + _tmp$11 = $pkg.ErrSyntax; + t = _tmp$10; + err = _tmp$11; + return [t, err]; + } + if (!contains(s, 92) && !contains(s, quote)) { + _4 = quote; + if (_4 === (34)) { + _tmp$12 = s; + _tmp$13 = $ifaceNil; + t = _tmp$12; + err = _tmp$13; + return [t, err]; + } else if (_4 === (39)) { + _tuple = utf8.DecodeRuneInString(s); + r = _tuple[0]; + size = _tuple[1]; + if ((size === s.length) && (!((r === 65533)) || !((size === 1)))) { + _tmp$14 = s; + _tmp$15 = $ifaceNil; + t = _tmp$14; + err = _tmp$15; + return [t, err]; + } + } + } + runeTmp = arrayType$4.zero(); + buf = $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$1 = _tuple$1[3]; + if (!($interfaceIsEqual(err$1, $ifaceNil))) { + _tmp$16 = ""; + _tmp$17 = err$1; + t = _tmp$16; + err = _tmp$17; + return [t, err]; + } + s = ss; + if (c < 128 || !multibyte) { + buf = $append(buf, (c << 24 >>> 24)); + } else { + n$1 = utf8.EncodeRune(new sliceType$6(runeTmp), c); + buf = $appendSlice(buf, $subslice(new sliceType$6(runeTmp), 0, n$1)); + } + if ((quote === 39) && !((s.length === 0))) { + _tmp$18 = ""; + _tmp$19 = $pkg.ErrSyntax; + t = _tmp$18; + err = _tmp$19; + return [t, err]; + } + } + _tmp$20 = $bytesToString(buf); + _tmp$21 = $ifaceNil; + t = _tmp$20; + err = _tmp$21; + return [t, err]; + }; + $pkg.Unquote = Unquote; + contains = function(s, c) { + var $ptr, c, i, s; + i = 0; + while (true) { + if (!(i < s.length)) { break; } + if (s.charCodeAt(i) === c) { + return true; + } + i = i + (1) >> 0; + } + return false; + }; + bsearch16 = function(a, x) { + var $ptr, _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") : a.$array[a.$offset + h]) < x) { + i = h + 1 >> 0; + } else { + j = h; + } + } + return i; + }; + bsearch32 = function(a, x) { + var $ptr, _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") : a.$array[a.$offset + h]) < x) { + i = h + 1 >> 0; + } else { + j = h; + } + } + return i; + }; + IsPrint = function(r) { + var $ptr, _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") : isPrint.$array[isPrint.$offset + x])) || (x$1 = i | 1, ((x$1 < 0 || x$1 >= isPrint.$length) ? $throwRuntimeError("index out of range") : 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") : 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") : 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") : 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") : isNotPrint$1.$array[isNotPrint$1.$offset + j$1]) === (r << 16 >>> 16))); + }; + $pkg.IsPrint = IsPrint; + isInGraphicList = function(r) { + var $ptr, 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") : 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", pkg: "", typ: $String, tag: ""}, {prop: "Num", name: "Num", pkg: "", typ: $String, tag: ""}, {prop: "Err", name: "Err", pkg: "", typ: $error, tag: ""}]); + decimal.init([{prop: "d", name: "d", pkg: "strconv", typ: arrayType, tag: ""}, {prop: "nd", name: "nd", pkg: "strconv", typ: $Int, tag: ""}, {prop: "dp", name: "dp", pkg: "strconv", typ: $Int, tag: ""}, {prop: "neg", name: "neg", pkg: "strconv", typ: $Bool, tag: ""}, {prop: "trunc", name: "trunc", pkg: "strconv", typ: $Bool, tag: ""}]); + leftCheat.init([{prop: "delta", name: "delta", pkg: "strconv", typ: $Int, tag: ""}, {prop: "cutoff", name: "cutoff", pkg: "strconv", typ: $String, tag: ""}]); + extFloat.init([{prop: "mant", name: "mant", pkg: "strconv", typ: $Uint64, tag: ""}, {prop: "exp", name: "exp", pkg: "strconv", typ: $Int, tag: ""}, {prop: "neg", name: "neg", pkg: "strconv", typ: $Bool, tag: ""}]); + floatInfo.init([{prop: "mantbits", name: "mantbits", pkg: "strconv", typ: $Uint, tag: ""}, {prop: "expbits", name: "expbits", pkg: "strconv", typ: $Uint, tag: ""}, {prop: "bias", name: "bias", pkg: "strconv", typ: $Int, tag: ""}]); + decimalSlice.init([{prop: "d", name: "d", pkg: "strconv", typ: sliceType$6, tag: ""}, {prop: "nd", name: "nd", pkg: "strconv", typ: $Int, tag: ""}, {prop: "dp", name: "dp", pkg: "strconv", typ: $Int, tag: ""}, {prop: "neg", name: "neg", pkg: "strconv", 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 = math.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = utf8.$init(); /* */ $s = 3; case 3: 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, 2142, 2208, 2228, 2275, 2444, 2447, 2448, 2451, 2482, 2486, 2489, 2492, 2500, 2503, 2504, 2507, 2510, 2519, 2519, 2524, 2531, 2534, 2555, 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, 2809, 2817, 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, 3329, 3386, 3389, 3406, 3415, 3415, 3423, 3427, 3430, 3445, 3449, 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, 7295, 7360, 7367, 7376, 7417, 7424, 7669, 7676, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8061, 8064, 8147, 8150, 8175, 8178, 8190, 8208, 8231, 8240, 8286, 8304, 8305, 8308, 8348, 8352, 8382, 8400, 8432, 8448, 8587, 8592, 9210, 9216, 9254, 9280, 9290, 9312, 11123, 11126, 11157, 11160, 11193, 11197, 11217, 11244, 11247, 11264, 11507, 11513, 11559, 11565, 11565, 11568, 11623, 11631, 11632, 11647, 11670, 11680, 11842, 11904, 12019, 12032, 12245, 12272, 12283, 12289, 12438, 12441, 12543, 12549, 12589, 12593, 12730, 12736, 12771, 12784, 19893, 19904, 40917, 40960, 42124, 42128, 42182, 42192, 42539, 42560, 42743, 42752, 42925, 42928, 42935, 42999, 43051, 43056, 43065, 43072, 43127, 43136, 43204, 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, 2436, 2473, 2481, 2526, 2564, 2601, 2609, 2612, 2615, 2621, 2653, 2692, 2702, 2706, 2729, 2737, 2740, 2758, 2762, 2820, 2857, 2865, 2868, 2910, 2948, 2961, 2971, 2973, 3017, 3076, 3085, 3089, 3113, 3141, 3145, 3159, 3200, 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, 7415, 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, 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, 65932, 65936, 65947, 65952, 65952, 66000, 66045, 66176, 66204, 66208, 66256, 66272, 66299, 66304, 66339, 66352, 66378, 66384, 66426, 66432, 66499, 66504, 66517, 66560, 66717, 66720, 66729, 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, 70205, 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, 70784, 70855, 70864, 70873, 71040, 71093, 71096, 71133, 71168, 71236, 71248, 71257, 71296, 71351, 71360, 71369, 71424, 71449, 71453, 71467, 71472, 71487, 71840, 71922, 71935, 71935, 72384, 72440, 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, 110592, 110593, 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, 124928, 125124, 125127, 125142, 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, 127386, 127462, 127490, 127504, 127546, 127552, 127560, 127568, 127569, 127744, 128720, 128736, 128748, 128752, 128755, 128768, 128883, 128896, 128980, 129024, 129035, 129040, 129095, 129104, 129113, 129120, 129159, 129168, 129197, 129296, 129304, 129408, 129412, 129472, 129472, 131072, 173782, 173824, 177972, 177984, 178205, 178208, 183969, 194560, 195101, 917760, 917999]); + isNotPrint32 = new sliceType$4([12, 39, 59, 62, 926, 2057, 2102, 2134, 2291, 2564, 2580, 2584, 4285, 4405, 4576, 4626, 4743, 4745, 4750, 4766, 4868, 4905, 4913, 4916, 9327, 27231, 27482, 27490, 54357, 54429, 54445, 54458, 54460, 54468, 54534, 54549, 54557, 54586, 54591, 54597, 54609, 55968, 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, 62842, 62884]); + isGraphic = new sliceType$4([160, 5760, 8192, 8193, 8194, 8195, 8196, 8197, 8198, 8199, 8200, 8201, 8202, 8239, 8287, 12288]); + shifts = $toNativeArray($kindUint, [0, 0, 1, 0, 2, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0]); + /* */ } 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 $ptr, f, h; + if (h >= 16) { + $panic(new $String("crypto: RegisterHash of unknown hash function")); + } + ((h < 0 || h >= hashes.$length) ? $throwRuntimeError("index out of range") : 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, 16); + /* */ } 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, hash, digest, sliceType, arrayType, arrayType$1, sliceType$1, arrayType$2, arrayType$4, ptrType, _K, init, New, New224, Sum256, block; + crypto = $packages["crypto"]; + hash = $packages["hash"]; + digest = $pkg.digest = $newType(0, $kindStruct, "sha256.digest", "digest", "crypto/sha256", function(h_, x_, nx_, len_, is224_) { + this.$val = this; + if (arguments.length === 0) { + this.h = arrayType.zero(); + this.x = arrayType$1.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); + arrayType = $arrayType($Uint32, 8); + arrayType$1 = $arrayType($Uint8, 64); + sliceType$1 = $sliceType($Uint8); + arrayType$2 = $arrayType($Uint8, 32); + arrayType$4 = $arrayType($Uint32, 64); + ptrType = $ptrType(digest); + init = function() { + var $ptr; + crypto.RegisterHash(4, New224); + crypto.RegisterHash(5, New); + }; + digest.ptr.prototype.Reset = function() { + var $ptr, 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 $ptr, d; + d = new digest.ptr(arrayType.zero(), arrayType$1.zero(), 0, new $Uint64(0, 0), false); + d.Reset(); + return d; + }; + $pkg.New = New; + New224 = function() { + var $ptr, d; + d = new digest.ptr(arrayType.zero(), arrayType$1.zero(), 0, new $Uint64(0, 0), false); + d.is224 = true; + d.Reset(); + return d; + }; + $pkg.New224 = New224; + digest.ptr.prototype.Size = function() { + var $ptr, d; + d = this; + if (!d.is224) { + return 32; + } + return 28; + }; + digest.prototype.Size = function() { return this.$val.Size(); }; + digest.ptr.prototype.BlockSize = function() { + var $ptr, d; + d = this; + return 64; + }; + digest.prototype.BlockSize = function() { return this.$val.BlockSize(); }; + digest.ptr.prototype.Write = function(p) { + var $ptr, d, err, n, n$1, nn, p, x, x$1; + 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) { + n = $copySlice($subslice(new sliceType$1(d.x), d.nx), p); + d.nx = d.nx + (n) >> 0; + if (d.nx === 64) { + block(d, new sliceType$1(d.x)); + d.nx = 0; + } + p = $subslice(p, n); + } + if (p.$length >= 64) { + n$1 = (p.$length & ~63) >> 0; + block(d, $subslice(p, 0, n$1)); + p = $subslice(p, n$1); + } + if (p.$length > 0) { + d.nx = $copySlice(new sliceType$1(d.x), p); + } + return [nn, err]; + }; + digest.prototype.Write = function(p) { return this.$val.Write(p); }; + digest.ptr.prototype.Sum = function(in$1) { + var $ptr, d, d0, hash$1, in$1; + d0 = this; + d = $clone(d0, digest); + hash$1 = $clone(d.checkSum(), arrayType$2); + if (d.is224) { + return $appendSlice(in$1, $subslice(new sliceType$1(hash$1), 0, 28)); + } + return $appendSlice(in$1, new sliceType$1(hash$1)); + }; + digest.prototype.Sum = function(in$1) { return this.$val.Sum(in$1); }; + digest.ptr.prototype.checkSum = function() { + var $ptr, _i, _ref, d, digest$1, h, i, i$1, len, s, tmp, x, x$1, x$2, x$3, x$4, x$5, x$6; + d = this; + len = d.len; + tmp = arrayType$1.zero(); + tmp[0] = 128; + if ((x = $div64(len, new $Uint64(0, 64), true), (x.$high < 0 || (x.$high === 0 && x.$low < 56)))) { + 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))))); + } else { + 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))))); + } + len = $shiftLeft64(len, (3)); + i = 0; + while (true) { + if (!(i < 8)) { break; } + ((i < 0 || i >= tmp.length) ? $throwRuntimeError("index out of range") : tmp[i] = ($shiftRightUint64(len, ((56 - (8 * i >>> 0) >>> 0))).$low << 24 >>> 24)); + i = i + (1) >>> 0; + } + d.Write($subslice(new sliceType$1(tmp), 0, 8)); + if (!((d.nx === 0))) { + $panic(new $String("d.nx != 0")); + } + h = new sliceType(d.h); + if (d.is224) { + h = $subslice(new sliceType(d.h), 0, 7); + } + digest$1 = arrayType$2.zero(); + _ref = h; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i$1 = _i; + s = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]); + (x$3 = $imul(i$1, 4), ((x$3 < 0 || x$3 >= digest$1.length) ? $throwRuntimeError("index out of range") : digest$1[x$3] = ((s >>> 24 >>> 0) << 24 >>> 24))); + (x$4 = ($imul(i$1, 4)) + 1 >> 0, ((x$4 < 0 || x$4 >= digest$1.length) ? $throwRuntimeError("index out of range") : digest$1[x$4] = ((s >>> 16 >>> 0) << 24 >>> 24))); + (x$5 = ($imul(i$1, 4)) + 2 >> 0, ((x$5 < 0 || x$5 >= digest$1.length) ? $throwRuntimeError("index out of range") : digest$1[x$5] = ((s >>> 8 >>> 0) << 24 >>> 24))); + (x$6 = ($imul(i$1, 4)) + 3 >> 0, ((x$6 < 0 || x$6 >= digest$1.length) ? $throwRuntimeError("index out of range") : digest$1[x$6] = (s << 24 >>> 24))); + _i++; + } + return digest$1; + }; + digest.prototype.checkSum = function() { return this.$val.checkSum(); }; + Sum256 = function(data) { + var $ptr, d, data; + d = new digest.ptr(arrayType.zero(), arrayType$1.zero(), 0, new $Uint64(0, 0), false); + d.Reset(); + d.Write(data); + return d.checkSum(); + }; + $pkg.Sum256 = Sum256; + block = function(dig, p) { + var $ptr, _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$4.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") : w[i] = ((((((((((j < 0 || j >= p.$length) ? $throwRuntimeError("index out of range") : p.$array[p.$offset + j]) >>> 0) << 24 >>> 0) | (((x = j + 1 >> 0, ((x < 0 || x >= p.$length) ? $throwRuntimeError("index out of range") : 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") : 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") : 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") : 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") : 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") : w[i$1] = (((t1 + (x$5 = i$1 - 7 >> 0, ((x$5 < 0 || x$5 >= w.length) ? $throwRuntimeError("index out of range") : w[x$5])) >>> 0) + t2 >>> 0) + (x$6 = i$1 - 16 >> 0, ((x$6 < 0 || x$6 >= w.length) ? $throwRuntimeError("index out of range") : 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") : _K.$array[_K.$offset + i$2]) >>> 0) + ((i$2 < 0 || i$2 >= w.length) ? $throwRuntimeError("index out of range") : 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: "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$2], false)}]; + digest.init([{prop: "h", name: "h", pkg: "crypto/sha256", typ: arrayType, tag: ""}, {prop: "x", name: "x", pkg: "crypto/sha256", typ: arrayType$1, tag: ""}, {prop: "nx", name: "nx", pkg: "crypto/sha256", typ: $Int, tag: ""}, {prop: "len", name: "len", pkg: "crypto/sha256", typ: $Uint64, tag: ""}, {prop: "is224", name: "is224", pkg: "crypto/sha256", 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 = hash.$init(); /* */ $s = 2; case 2: 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]); + init(); + /* */ } 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, io, strconv, Encoding, encoder, CorruptInputError, arrayType, arrayType$1, sliceType, ptrType, arrayType$2, arrayType$3, arrayType$4, ptrType$1, NewEncoding, NewEncoder; + io = $packages["io"]; + strconv = $packages["strconv"]; + Encoding = $pkg.Encoding = $newType(0, $kindStruct, "base64.Encoding", "Encoding", "encoding/base64", function(encode_, decodeMap_, padChar_) { + this.$val = this; + if (arguments.length === 0) { + this.encode = arrayType.zero(); + this.decodeMap = arrayType$1.zero(); + this.padChar = 0; + return; + } + this.encode = encode_; + this.decodeMap = decodeMap_; + this.padChar = padChar_; + }); + encoder = $pkg.encoder = $newType(0, $kindStruct, "base64.encoder", "encoder", "encoding/base64", 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", "CorruptInputError", "encoding/base64", 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 $ptr, e, encoder$1, i, i$1, x, x$1, x$2; + if (!((encoder$1.length === 64))) { + $panic(new $String("encoding alphabet is not 64-bytes long")); + } + e = new Encoding.ptr(arrayType.zero(), arrayType$1.zero(), 0); + e.padChar = 61; + $copyString(new sliceType(e.encode), encoder$1); + i = 0; + while (true) { + if (!(i < 256)) { break; } + (x = e.decodeMap, ((i < 0 || i >= x.length) ? $throwRuntimeError("index out of range") : x[i] = 255)); + i = i + (1) >> 0; + } + i$1 = 0; + while (true) { + if (!(i$1 < encoder$1.length)) { break; } + (x$1 = e.decodeMap, x$2 = encoder$1.charCodeAt(i$1), ((x$2 < 0 || x$2 >= x$1.length) ? $throwRuntimeError("index out of range") : x$1[x$2] = (i$1 << 24 >>> 24))); + i$1 = i$1 + (1) >> 0; + } + return e; + }; + $pkg.NewEncoding = NewEncoding; + Encoding.ptr.prototype.WithPadding = function(padding) { + var $ptr, enc, padding; + enc = $clone(this, Encoding); + enc.padChar = padding; + return enc; + }; + Encoding.prototype.WithPadding = function(padding) { return this.$val.WithPadding(padding); }; + Encoding.ptr.prototype.Encode = function(dst, src) { + var $ptr, _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") : 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") : 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") : 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") : 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") : x$3[x$4])))); + (x$8 = di + 1 >> 0, ((x$8 < 0 || x$8 >= dst.$length) ? $throwRuntimeError("index out of range") : 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") : x$6[x$7])))); + (x$11 = di + 2 >> 0, ((x$11 < 0 || x$11 >= dst.$length) ? $throwRuntimeError("index out of range") : 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") : x$9[x$10])))); + (x$14 = di + 3 >> 0, ((x$14 < 0 || x$14 >= dst.$length) ? $throwRuntimeError("index out of range") : 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") : 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") : 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") : 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") : 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") : x$17[x$18])))); + (x$22 = di + 1 >> 0, ((x$22 < 0 || x$22 >= dst.$length) ? $throwRuntimeError("index out of range") : 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") : 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") : 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") : 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") : 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") : 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") : 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 $ptr, 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 $ptr, _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; $ptr = $f.$ptr; _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; + 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") : x[x$1] = ((i < 0 || i >= p.$length) ? $throwRuntimeError("index out of range") : 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) { + 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; + 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; + 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") : x$2[i$1] = ((i$1 < 0 || i$1 >= p.$length) ? $throwRuntimeError("index out of range") : p.$array[p.$offset + i$1]))); + i$1 = i$1 + (1) >> 0; + } + e.nbuf = p.$length; + n = n + (p.$length) >> 0; + return [n, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: encoder.ptr.prototype.Write }; } $f.$ptr = $ptr; $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 $ptr, _r, _tuple, e, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _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: + return e.err; + /* */ } return; } if ($f === undefined) { $f = { $blk: encoder.ptr.prototype.Close }; } $f.$ptr = $ptr; $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 $ptr, 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 $ptr, _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 $ptr, 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.decode = function(dst, src) { + var $ptr, _2, _3, _i, _ref, _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$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, _tmp$9, dbuf, dinc, dlen, dst, enc, end, err, in$1, j, n, si, src, val, x; + n = 0; + end = false; + err = $ifaceNil; + enc = this; + si = 0; + while (true) { + if (!(si < src.$length && ((((si < 0 || si >= src.$length) ? $throwRuntimeError("index out of range") : src.$array[src.$offset + si]) === 10) || (((si < 0 || si >= src.$length) ? $throwRuntimeError("index out of range") : src.$array[src.$offset + si]) === 13)))) { break; } + si = si + (1) >> 0; + } + while (true) { + if (!(si < src.$length && !end)) { break; } + dbuf = arrayType$4.zero(); + _tmp = 3; + _tmp$1 = 4; + dinc = _tmp; + dlen = _tmp$1; + _ref = dbuf; + _i = 0; + while (true) { + if (!(_i < 4)) { break; } + j = _i; + if (src.$length === si) { + if (!((enc.padChar === -1)) || j < 2) { + _tmp$2 = n; + _tmp$3 = false; + _tmp$4 = new CorruptInputError(0, (si - j >> 0)); + n = _tmp$2; + end = _tmp$3; + err = _tmp$4; + return [n, end, err]; + } + _tmp$5 = j - 1 >> 0; + _tmp$6 = j; + _tmp$7 = true; + dinc = _tmp$5; + dlen = _tmp$6; + end = _tmp$7; + break; + } + in$1 = ((si < 0 || si >= src.$length) ? $throwRuntimeError("index out of range") : src.$array[src.$offset + si]); + si = si + (1) >> 0; + while (true) { + if (!(si < src.$length && ((((si < 0 || si >= src.$length) ? $throwRuntimeError("index out of range") : src.$array[src.$offset + si]) === 10) || (((si < 0 || si >= src.$length) ? $throwRuntimeError("index out of range") : src.$array[src.$offset + si]) === 13)))) { break; } + si = si + (1) >> 0; + } + if ((in$1 >> 0) === enc.padChar) { + _2 = j; + if ((_2 === (0)) || (_2 === (1))) { + _tmp$8 = n; + _tmp$9 = false; + _tmp$10 = new CorruptInputError(0, (si - 1 >> 0)); + n = _tmp$8; + end = _tmp$9; + err = _tmp$10; + return [n, end, err]; + } else if (_2 === (2)) { + if (si === src.$length) { + _tmp$11 = n; + _tmp$12 = false; + _tmp$13 = new CorruptInputError(0, src.$length); + n = _tmp$11; + end = _tmp$12; + err = _tmp$13; + return [n, end, err]; + } + if (!(((((si < 0 || si >= src.$length) ? $throwRuntimeError("index out of range") : src.$array[src.$offset + si]) >> 0) === enc.padChar))) { + _tmp$14 = n; + _tmp$15 = false; + _tmp$16 = new CorruptInputError(0, (si - 1 >> 0)); + n = _tmp$14; + end = _tmp$15; + err = _tmp$16; + return [n, end, err]; + } + si = si + (1) >> 0; + while (true) { + if (!(si < src.$length && ((((si < 0 || si >= src.$length) ? $throwRuntimeError("index out of range") : src.$array[src.$offset + si]) === 10) || (((si < 0 || si >= src.$length) ? $throwRuntimeError("index out of range") : src.$array[src.$offset + si]) === 13)))) { break; } + si = si + (1) >> 0; + } + } + if (si < src.$length) { + err = new CorruptInputError(0, si); + } + _tmp$17 = 3; + _tmp$18 = j; + _tmp$19 = true; + dinc = _tmp$17; + dlen = _tmp$18; + end = _tmp$19; + break; + } + ((j < 0 || j >= dbuf.length) ? $throwRuntimeError("index out of range") : dbuf[j] = (x = enc.decodeMap, ((in$1 < 0 || in$1 >= x.length) ? $throwRuntimeError("index out of range") : x[in$1]))); + if (((j < 0 || j >= dbuf.length) ? $throwRuntimeError("index out of range") : dbuf[j]) === 255) { + _tmp$20 = n; + _tmp$21 = false; + _tmp$22 = new CorruptInputError(0, (si - 1 >> 0)); + n = _tmp$20; + end = _tmp$21; + err = _tmp$22; + return [n, end, err]; + } + _i++; + } + val = (((((((dbuf[0] >>> 0) << 18 >>> 0) | ((dbuf[1] >>> 0) << 12 >>> 0)) >>> 0) | ((dbuf[2] >>> 0) << 6 >>> 0)) >>> 0) | (dbuf[3] >>> 0)) >>> 0; + _3 = dlen; + if (_3 === (4)) { + (2 >= dst.$length ? $throwRuntimeError("index out of range") : dst.$array[dst.$offset + 2] = ((val >>> 0 >>> 0) << 24 >>> 24)); + (1 >= dst.$length ? $throwRuntimeError("index out of range") : dst.$array[dst.$offset + 1] = ((val >>> 8 >>> 0) << 24 >>> 24)); + (0 >= dst.$length ? $throwRuntimeError("index out of range") : dst.$array[dst.$offset + 0] = ((val >>> 16 >>> 0) << 24 >>> 24)); + } else if (_3 === (3)) { + (1 >= dst.$length ? $throwRuntimeError("index out of range") : dst.$array[dst.$offset + 1] = ((val >>> 8 >>> 0) << 24 >>> 24)); + (0 >= dst.$length ? $throwRuntimeError("index out of range") : dst.$array[dst.$offset + 0] = ((val >>> 16 >>> 0) << 24 >>> 24)); + } else if (_3 === (2)) { + (0 >= dst.$length ? $throwRuntimeError("index out of range") : dst.$array[dst.$offset + 0] = ((val >>> 16 >>> 0) << 24 >>> 24)); + } + dst = $subslice(dst, dinc); + n = n + ((dlen - 1 >> 0)) >> 0; + } + _tmp$23 = n; + _tmp$24 = end; + _tmp$25 = err; + n = _tmp$23; + end = _tmp$24; + err = _tmp$25; + return [n, end, err]; + }; + Encoding.prototype.decode = function(dst, src) { return this.$val.decode(dst, src); }; + Encoding.ptr.prototype.Decode = function(dst, src) { + var $ptr, _tuple, dst, enc, err, n, src; + n = 0; + err = $ifaceNil; + enc = this; + _tuple = enc.decode(dst, src); + n = _tuple[0]; + err = _tuple[2]; + return [n, err]; + }; + Encoding.prototype.Decode = function(dst, src) { return this.$val.Decode(dst, src); }; + Encoding.ptr.prototype.DecodeString = function(s) { + var $ptr, _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[2]; + return [$subslice(dbuf, 0, n), err]; + }; + Encoding.prototype.DecodeString = function(s) { return this.$val.DecodeString(s); }; + Encoding.ptr.prototype.DecodedLen = function(n) { + var $ptr, _q, _q$1, enc, n; + enc = this; + if (enc.padChar === -1) { + return (_q = ((($imul(n, 6)) + 7 >> 0)) / 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)}]; + 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: "decode", name: "decode", pkg: "encoding/base64", typ: $funcType([sliceType, sliceType], [$Int, $Bool, $error], false)}, {prop: "Decode", name: "Decode", pkg: "", typ: $funcType([sliceType, sliceType], [$Int, $error], false)}, {prop: "DecodeString", name: "DecodeString", pkg: "", typ: $funcType([$String], [sliceType, $error], 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([{prop: "encode", name: "encode", pkg: "encoding/base64", typ: arrayType, tag: ""}, {prop: "decodeMap", name: "decodeMap", pkg: "encoding/base64", typ: arrayType$1, tag: ""}, {prop: "padChar", name: "padChar", pkg: "encoding/base64", typ: $Int32, tag: ""}]); + encoder.init([{prop: "err", name: "err", pkg: "encoding/base64", typ: $error, tag: ""}, {prop: "enc", name: "enc", pkg: "encoding/base64", typ: ptrType, tag: ""}, {prop: "w", name: "w", pkg: "encoding/base64", typ: io.Writer, tag: ""}, {prop: "buf", name: "buf", pkg: "encoding/base64", typ: arrayType$2, tag: ""}, {prop: "nbuf", name: "nbuf", pkg: "encoding/base64", typ: $Int, tag: ""}, {prop: "out", name: "out", pkg: "encoding/base64", 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 = io.$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; } + $pkg.StdEncoding = NewEncoding("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"); + $pkg.URLEncoding = NewEncoding("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"); + $pkg.RawStdEncoding = $pkg.StdEncoding.WithPadding(-1); + $pkg.RawURLEncoding = $pkg.URLEncoding.WithPadding(-1); + /* */ } 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, sliceType$3, sliceType$4, _L, _Nd, _CaseRanges, properties, caseOrbit, to, IsDigit, IsLetter, is16, is32, isExcludingLatin, To, ToUpper, ToLower, SimpleFold; + RangeTable = $pkg.RangeTable = $newType(0, $kindStruct, "unicode.RangeTable", "RangeTable", "unicode", 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", "Range16", "unicode", 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", "Range32", "unicode", 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", "CaseRange", "unicode", 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", "d", "unicode", null); + foldPair = $pkg.foldPair = $newType(0, $kindStruct, "unicode.foldPair", "foldPair", "unicode", 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); + sliceType$3 = $sliceType(CaseRange); + sliceType$4 = $sliceType(foldPair); + to = function(_case, r, caseRange) { + var $ptr, _case, _q, caseRange, cr, delta, hi, lo, m, r, x; + if (_case < 0 || 3 <= _case) { + return 65533; + } + 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") : 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") : x[_case])); + if (delta > 1114111) { + return (cr.Lo >> 0) + ((((((r - (cr.Lo >> 0) >> 0)) & ~1) >> 0) | ((_case & 1) >> 0))) >> 0; + } + return r + delta >> 0; + } + if (r < (cr.Lo >> 0)) { + hi = m; + } else { + lo = m + 1 >> 0; + } + } + return r; + }; + IsDigit = function(r) { + var $ptr, r; + if (r <= 255) { + return 48 <= r && r <= 57; + } + return isExcludingLatin($pkg.Digit, r); + }; + $pkg.IsDigit = IsDigit; + IsLetter = function(r) { + var $ptr, r, x; + if ((r >>> 0) <= 255) { + return !(((((x = (r << 24 >>> 24), ((x < 0 || x >= properties.length) ? $throwRuntimeError("index out of range") : properties[x])) & 96) >>> 0) === 0)); + } + return isExcludingLatin($pkg.Letter, r); + }; + $pkg.IsLetter = IsLetter; + is16 = function(ranges, r) { + var $ptr, _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") : ranges.$array[ranges.$offset + i]); + if (r < range_.Lo) { + return false; + } + if (r <= range_.Hi) { + return (_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") : ranges.$array[ranges.$offset + m]); + if (range_$1.Lo <= r && r <= range_$1.Hi) { + return (_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 $ptr, _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") : ranges.$array[ranges.$offset + i]); + if (r < range_.Lo) { + return false; + } + if (r <= range_.Hi) { + return (_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") : ranges.$array[ranges.$offset + m]), Range32); + if (range_$1.Lo <= r && r <= range_$1.Hi) { + return (_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; + }; + isExcludingLatin = function(rangeTab, r) { + var $ptr, 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") : 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") : r32.$array[r32.$offset + 0]).Lo >> 0)) { + return is32(r32, (r >>> 0)); + } + return false; + }; + To = function(_case, r) { + var $ptr, _case, r; + return to(_case, r, $pkg.CaseRanges); + }; + $pkg.To = To; + ToUpper = function(r) { + var $ptr, 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 $ptr, 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 $ptr, _q, hi, l, lo, m, r; + 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") : 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") : caseOrbit.$array[caseOrbit.$offset + lo]).From >> 0) === r)) { + return (((lo < 0 || lo >= caseOrbit.$length) ? $throwRuntimeError("index out of range") : 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", pkg: "", typ: sliceType, tag: ""}, {prop: "R32", name: "R32", pkg: "", typ: sliceType$1, tag: ""}, {prop: "LatinOffset", name: "LatinOffset", pkg: "", typ: $Int, tag: ""}]); + Range16.init([{prop: "Lo", name: "Lo", pkg: "", typ: $Uint16, tag: ""}, {prop: "Hi", name: "Hi", pkg: "", typ: $Uint16, tag: ""}, {prop: "Stride", name: "Stride", pkg: "", typ: $Uint16, tag: ""}]); + Range32.init([{prop: "Lo", name: "Lo", pkg: "", typ: $Uint32, tag: ""}, {prop: "Hi", name: "Hi", pkg: "", typ: $Uint32, tag: ""}, {prop: "Stride", name: "Stride", pkg: "", typ: $Uint32, tag: ""}]); + CaseRange.init([{prop: "Lo", name: "Lo", pkg: "", typ: $Uint32, tag: ""}, {prop: "Hi", name: "Hi", pkg: "", typ: $Uint32, tag: ""}, {prop: "Delta", name: "Delta", pkg: "", typ: d, tag: ""}]); + d.init($Int32, 3); + foldPair.init([{prop: "From", name: "From", pkg: "", typ: $Uint16, tag: ""}, {prop: "To", name: "To", pkg: "", 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: + _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(2208, 2228, 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(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(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(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(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, 3423, 17), new Range16.ptr(3424, 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, 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(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, 12589, 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, 40917, 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, 42925, 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(66352, 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(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(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, 72384, 449), new Range32.ptr(72385, 72440, 1), new Range32.ptr(73728, 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(110592, 110593, 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(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(194560, 195101, 1)]), 6); + _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(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(92768, 92777, 1), new Range32.ptr(93008, 93017, 1), new Range32.ptr(120782, 120831, 1)]), 1); + $pkg.Digit = _Nd; + $pkg.Letter = _L; + _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(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(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(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(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]))]); + $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]); + 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(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)]); + /* */ } 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, io, unicode, utf8, Buffer, readOp, ptrType, sliceType, arrayType, arrayType$1, IndexByte, makeSlice, EqualFold; + errors = $packages["errors"]; + io = $packages["io"]; + unicode = $packages["unicode"]; + utf8 = $packages["unicode/utf8"]; + Buffer = $pkg.Buffer = $newType(0, $kindStruct, "bytes.Buffer", "Buffer", "bytes", function(buf_, off_, runeBytes_, bootstrap_, lastRead_) { + this.$val = this; + if (arguments.length === 0) { + this.buf = sliceType.nil; + this.off = 0; + this.runeBytes = arrayType.zero(); + this.bootstrap = arrayType$1.zero(); + this.lastRead = 0; + return; + } + this.buf = buf_; + this.off = off_; + this.runeBytes = runeBytes_; + this.bootstrap = bootstrap_; + this.lastRead = lastRead_; + }); + readOp = $pkg.readOp = $newType(4, $kindInt, "bytes.readOp", "readOp", "bytes", null); + ptrType = $ptrType(Buffer); + sliceType = $sliceType($Uint8); + arrayType = $arrayType($Uint8, 4); + arrayType$1 = $arrayType($Uint8, 64); + IndexByte = function(s, c) { + var $ptr, _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") : _ref.$array[_ref.$offset + _i]); + if (b === c) { + return i; + } + _i++; + } + return -1; + }; + $pkg.IndexByte = IndexByte; + Buffer.ptr.prototype.Bytes = function() { + var $ptr, b; + b = this; + return $subslice(b.buf, b.off); + }; + Buffer.prototype.Bytes = function() { return this.$val.Bytes(); }; + Buffer.ptr.prototype.String = function() { + var $ptr, 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.Len = function() { + var $ptr, b; + b = this; + return b.buf.$length - b.off >> 0; + }; + Buffer.prototype.Len = function() { return this.$val.Len(); }; + Buffer.ptr.prototype.Cap = function() { + var $ptr, b; + b = this; + return b.buf.$capacity; + }; + Buffer.prototype.Cap = function() { return this.$val.Cap(); }; + Buffer.ptr.prototype.Truncate = function(n) { + var $ptr, b, n; + b = this; + b.lastRead = 0; + if (n < 0 || n > b.Len()) { + $panic(new $String("bytes.Buffer: truncation out of range")); + } else if ((n === 0)) { + b.off = 0; + } + 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 $ptr, b; + b = this; + b.Truncate(0); + }; + Buffer.prototype.Reset = function() { return this.$val.Reset(); }; + Buffer.ptr.prototype.grow = function(n) { + var $ptr, _q, b, buf, m, n; + b = this; + m = b.Len(); + if ((m === 0) && !((b.off === 0))) { + b.Truncate(0); + } + if ((b.buf.$length + n >> 0) > b.buf.$capacity) { + buf = sliceType.nil; + if (b.buf === sliceType.nil && n <= 64) { + buf = $subslice(new sliceType(b.bootstrap), 0); + } else if ((m + n >> 0) <= (_q = b.buf.$capacity / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero"))) { + $copySlice(b.buf, $subslice(b.buf, b.off)); + buf = $subslice(b.buf, 0, m); + } else { + buf = makeSlice(($imul(2, b.buf.$capacity)) + n >> 0); + $copySlice(buf, $subslice(b.buf, b.off)); + } + b.buf = buf; + b.off = 0; + } + b.buf = $subslice(b.buf, 0, ((b.off + m >> 0) + n >> 0)); + return b.off + m >> 0; + }; + Buffer.prototype.grow = function(n) { return this.$val.grow(n); }; + Buffer.ptr.prototype.Grow = function(n) { + var $ptr, 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 $ptr, _tmp, _tmp$1, b, err, m, n, p; + n = 0; + err = $ifaceNil; + b = this; + b.lastRead = 0; + 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 $ptr, _tmp, _tmp$1, b, err, m, n, s; + n = 0; + err = $ifaceNil; + b = this; + b.lastRead = 0; + 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 $ptr, _r, _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, b, e, err, free, m, n, newBuf, r, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _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; free = $f.free; m = $f.m; n = $f.n; newBuf = $f.newBuf; 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; + if (b.off >= b.buf.$length) { + b.Truncate(0); + } + /* while (true) { */ case 1: + free = b.buf.$capacity - b.buf.$length >> 0; + if (free < 512) { + newBuf = b.buf; + if ((b.off + free >> 0) < 512) { + newBuf = makeSlice(($imul(2, b.buf.$capacity)) + 512 >> 0); + } + $copySlice(newBuf, $subslice(b.buf, b.off)); + b.buf = $subslice(newBuf, 0, (b.buf.$length - b.off >> 0)); + b.off = 0; + } + _r = r.Read($subslice(b.buf, b.buf.$length, 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]; + b.buf = $subslice(b.buf, 0, (b.buf.$length + m >> 0)); + n = (x = new $Int64(0, m), new $Int64(n.$high + x.$high, n.$low + x.$low)); + if ($interfaceIsEqual(e, io.EOF)) { + /* break; */ $s = 2; continue; + } + if (!($interfaceIsEqual(e, $ifaceNil))) { + _tmp = n; + _tmp$1 = e; + n = _tmp; + err = _tmp$1; + return [n, err]; + } + /* } */ $s = 1; continue; case 2: + _tmp$2 = n; + _tmp$3 = $ifaceNil; + n = _tmp$2; + err = _tmp$3; + return [n, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Buffer.ptr.prototype.ReadFrom }; } $f.$ptr = $ptr; $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.free = free; $f.m = m; $f.n = n; $f.newBuf = newBuf; $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 $ptr, n, $deferred; + /* */ var $err = null; try { $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + $deferred.push([(function() { + var $ptr; + 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 $ptr, _r, _tmp, _tmp$1, _tmp$2, _tmp$3, _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; $ptr = $f.$ptr; _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; 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; + /* */ if (b.off < b.buf.$length) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (b.off < b.buf.$length) { */ case 1: + nBytes = b.Len(); + _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; + return [n, err]; + } + if (!((m === nBytes))) { + _tmp$2 = n; + _tmp$3 = io.ErrShortWrite; + n = _tmp$2; + err = _tmp$3; + return [n, err]; + } + /* } */ case 2: + b.Truncate(0); + return [n, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Buffer.ptr.prototype.WriteTo }; } $f.$ptr = $ptr; $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.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 $ptr, b, c, m, x; + b = this; + b.lastRead = 0; + m = b.grow(1); + (x = b.buf, ((m < 0 || m >= x.$length) ? $throwRuntimeError("index out of range") : 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 $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, b, err, n, 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]; + } + n = utf8.EncodeRune($subslice(new sliceType(b.runeBytes), 0), r); + b.Write($subslice(new sliceType(b.runeBytes), 0, n)); + _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 $ptr, _tmp, _tmp$1, b, err, n, p; + n = 0; + err = $ifaceNil; + b = this; + b.lastRead = 0; + if (b.off >= b.buf.$length) { + b.Truncate(0); + if (p.$length === 0) { + return [n, err]; + } + _tmp = 0; + _tmp$1 = io.EOF; + n = _tmp; + err = _tmp$1; + return [n, err]; + } + n = $copySlice(p, $subslice(b.buf, b.off)); + b.off = b.off + (n) >> 0; + if (n > 0) { + b.lastRead = 2; + } + return [n, err]; + }; + Buffer.prototype.Read = function(p) { return this.$val.Read(p); }; + Buffer.ptr.prototype.Next = function(n) { + var $ptr, 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 = 2; + } + return data; + }; + Buffer.prototype.Next = function(n) { return this.$val.Next(n); }; + Buffer.ptr.prototype.ReadByte = function() { + var $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, b, c, err, x, x$1; + c = 0; + err = $ifaceNil; + b = this; + b.lastRead = 0; + if (b.off >= b.buf.$length) { + b.Truncate(0); + _tmp = 0; + _tmp$1 = io.EOF; + c = _tmp; + err = _tmp$1; + return [c, err]; + } + c = (x = b.buf, x$1 = b.off, ((x$1 < 0 || x$1 >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + x$1])); + b.off = b.off + (1) >> 0; + b.lastRead = 2; + _tmp$2 = c; + _tmp$3 = $ifaceNil; + c = _tmp$2; + err = _tmp$3; + return [c, err]; + }; + Buffer.prototype.ReadByte = function() { return this.$val.ReadByte(); }; + Buffer.ptr.prototype.ReadRune = function() { + var $ptr, _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; + b.lastRead = 0; + if (b.off >= b.buf.$length) { + b.Truncate(0); + _tmp = 0; + _tmp$1 = 0; + _tmp$2 = io.EOF; + r = _tmp; + size = _tmp$1; + err = _tmp$2; + return [r, size, err]; + } + b.lastRead = 1; + c = (x = b.buf, x$1 = b.off, ((x$1 < 0 || x$1 >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + x$1])); + if (c < 128) { + b.off = b.off + (1) >> 0; + _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; + _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 $ptr, _tuple, b, n; + b = this; + if (!((b.lastRead === 1))) { + return errors.New("bytes.Buffer: UnreadRune: previous operation was not ReadRune"); + } + b.lastRead = 0; + if (b.off > 0) { + _tuple = utf8.DecodeLastRune($subslice(b.buf, 0, b.off)); + n = _tuple[1]; + b.off = b.off - (n) >> 0; + } + return $ifaceNil; + }; + Buffer.prototype.UnreadRune = function() { return this.$val.UnreadRune(); }; + Buffer.ptr.prototype.UnreadByte = function() { + var $ptr, b; + b = this; + if (!((b.lastRead === 1)) && !((b.lastRead === 2))) { + return errors.New("bytes.Buffer: UnreadByte: previous operation was not a 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 $ptr, _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); + return [line, err]; + }; + Buffer.prototype.ReadBytes = function(delim) { return this.$val.ReadBytes(delim); }; + Buffer.ptr.prototype.readSlice = function(delim) { + var $ptr, _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 = 2; + _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 $ptr, _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); }; + EqualFold = function(s, t) { + var $ptr, _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") : s.$array[s.$offset + 0]) < 128) { + _tmp$2 = ((0 >= s.$length ? $throwRuntimeError("index out of range") : 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") : t.$array[t.$offset + 0]) < 128) { + _tmp$6 = ((0 >= t.$length ? $throwRuntimeError("index out of range") : 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 && 65 <= sr && sr <= 90) { + if (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; + ptrType.methods = [{prop: "Bytes", name: "Bytes", pkg: "", typ: $funcType([], [sliceType], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], 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: "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)}]; + Buffer.init([{prop: "buf", name: "buf", pkg: "bytes", typ: sliceType, tag: ""}, {prop: "off", name: "off", pkg: "bytes", typ: $Int, tag: ""}, {prop: "runeBytes", name: "runeBytes", pkg: "bytes", typ: arrayType, tag: ""}, {prop: "bootstrap", name: "bootstrap", pkg: "bytes", typ: arrayType$1, tag: ""}, {prop: "lastRead", name: "lastRead", pkg: "bytes", typ: readOp, 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 = unicode.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = utf8.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $pkg.ErrTooLarge = errors.New("bytes.Buffer: too large"); + /* */ } 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, sliceType; + TextMarshaler = $pkg.TextMarshaler = $newType(8, $kindInterface, "encoding.TextMarshaler", "TextMarshaler", "encoding", null); + sliceType = $sliceType($Uint8); + TextMarshaler.init([{prop: "MarshalText", name: "MarshalText", 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["syscall"] = (function() { + var $pkg = {}, $init, js, race, runtime, sync, mmapper, Errno, Timespec, Stat_t, Dirent, sliceType, sliceType$1, ptrType$2, arrayType$5, arrayType$13, arrayType$14, structType, ptrType$22, ptrType$25, mapType, funcType, funcType$1, ptrType$29, arrayType$18, warningPrinted, lineBuffer, syscallModule, alreadyTriedToLoad, minusOne, envOnce, envLock, env, envs, mapper, errEAGAIN, errEINVAL, errENOENT, ioSync, ioSync$24ptr, errors, init, printWarning, printToConsole, use, indexByte, runtime_envs, syscall, Syscall, Syscall6, BytePtrFromString, copyenv, Getenv, msanRead, msanWrite, itoa, uitoa, clen, ReadDirent, ParseDirent, errnoErr, Read, Write, Close, Exit, Fchdir, Fchmod, Fsync, Getdents, read, write, munmap, Fchown, Fstat, Ftruncate, Lstat, Pread, Pwrite, Seek, mmap; + js = $packages["github.com/gopherjs/gopherjs/js"]; + race = $packages["internal/race"]; + runtime = $packages["runtime"]; + sync = $packages["sync"]; + mmapper = $pkg.mmapper = $newType(0, $kindStruct, "syscall.mmapper", "mmapper", "syscall", 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", "Errno", "syscall", null); + Timespec = $pkg.Timespec = $newType(0, $kindStruct, "syscall.Timespec", "Timespec", "syscall", 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", "Stat_t", "syscall", 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$18.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_; + }); + Dirent = $pkg.Dirent = $newType(0, $kindStruct, "syscall.Dirent", "Dirent", "syscall", function(Ino_, Off_, Reclen_, Type_, Name_, Pad_cgo_0_) { + this.$val = this; + if (arguments.length === 0) { + this.Ino = new $Uint64(0, 0); + this.Off = new $Int64(0, 0); + this.Reclen = 0; + this.Type = 0; + this.Name = arrayType$13.zero(); + this.Pad_cgo_0 = arrayType$14.zero(); + return; + } + this.Ino = Ino_; + this.Off = Off_; + this.Reclen = Reclen_; + this.Type = Type_; + this.Name = Name_; + this.Pad_cgo_0 = Pad_cgo_0_; + }); + sliceType = $sliceType($Uint8); + sliceType$1 = $sliceType($String); + ptrType$2 = $ptrType($Uint8); + arrayType$5 = $arrayType($Uint8, 32); + arrayType$13 = $arrayType($Int8, 256); + arrayType$14 = $arrayType($Uint8, 5); + structType = $structType([{prop: "addr", name: "addr", pkg: "syscall", typ: $Uintptr, tag: ""}, {prop: "len", name: "len", pkg: "syscall", typ: $Int, tag: ""}, {prop: "cap", name: "cap", pkg: "syscall", typ: $Int, tag: ""}]); + ptrType$22 = $ptrType($Int64); + ptrType$25 = $ptrType(mmapper); + mapType = $mapType(ptrType$2, sliceType); + funcType = $funcType([$Uintptr, $Uintptr, $Int, $Int, $Int, $Int64], [$Uintptr, $error], false); + funcType$1 = $funcType([$Uintptr, $Uintptr], [$error], false); + ptrType$29 = $ptrType(Timespec); + arrayType$18 = $arrayType($Int64, 3); + init = function() { + var $ptr; + $flushConsole = (function() { + var $ptr; + if (!((lineBuffer.$length === 0))) { + $global.console.log($externalize($bytesToString(lineBuffer), $String)); + lineBuffer = sliceType.nil; + } + }); + }; + printWarning = function() { + var $ptr; + 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 $ptr, 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)); + } + }; + use = function(p) { + var $ptr, p; + }; + indexByte = function(s, c) { + var $ptr, _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") : _ref.$array[_ref.$offset + _i]); + if (b === c) { + return i; + } + _i++; + } + return -1; + }; + runtime_envs = function() { + var $ptr, 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") : envs$1.$array[envs$1.$offset + i] = key + "=" + $internalize(jsEnv[$externalize(key, $String)], $String)); + i = i + (1) >> 0; + } + return envs$1; + }; + syscall = function(name) { + var $ptr, name, require, $deferred; + /* */ var $err = null; try { $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + $deferred.push([(function() { + var $ptr; + $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 $ptr, _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 = syscall("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 === 60) { + 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 $ptr, _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 = syscall("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 $ptr, _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") : _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; + copyenv = function() { + var $ptr, _entry, _i, _key, _ref, _tuple, i, j, key, ok, s; + env = {}; + _ref = envs; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + s = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]); + j = 0; + while (true) { + if (!(j < s.length)) { break; } + if (s.charCodeAt(j) === 61) { + key = s.substring(0, j); + _tuple = (_entry = env[$String.keyFor(key)], _entry !== undefined ? [_entry.v, true] : [0, false]); + ok = _tuple[1]; + if (!ok) { + _key = key; (env || $throwRuntimeError("assignment to entry in nil map"))[$String.keyFor(_key)] = { k: _key, v: i }; + } else { + ((i < 0 || i >= envs.$length) ? $throwRuntimeError("index out of range") : envs.$array[envs.$offset + i] = ""); + } + break; + } + j = j + (1) >> 0; + } + _i++; + } + }; + Getenv = function(key) { + var $ptr, _entry, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tuple, found, i, i$1, key, ok, s, value, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _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; found = $f.found; i = $f.i; i$1 = $f.i$1; key = $f.key; ok = $f.ok; s = $f.s; value = $f.value; $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); + value = ""; + found = false; + $r = envOnce.Do(copyenv); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + if (key.length === 0) { + _tmp = ""; + _tmp$1 = false; + value = _tmp; + found = _tmp$1; + return [value, found]; + } + $r = envLock.RLock(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $deferred.push([$methodVal(envLock, "RUnlock"), []]); + _tuple = (_entry = env[$String.keyFor(key)], _entry !== undefined ? [_entry.v, true] : [0, false]); + i = _tuple[0]; + ok = _tuple[1]; + if (!ok) { + _tmp$2 = ""; + _tmp$3 = false; + value = _tmp$2; + found = _tmp$3; + return [value, found]; + } + s = ((i < 0 || i >= envs.$length) ? $throwRuntimeError("index out of range") : envs.$array[envs.$offset + i]); + i$1 = 0; + while (true) { + if (!(i$1 < s.length)) { break; } + if (s.charCodeAt(i$1) === 61) { + _tmp$4 = s.substring((i$1 + 1 >> 0)); + _tmp$5 = true; + value = _tmp$4; + found = _tmp$5; + return [value, found]; + } + i$1 = i$1 + (1) >> 0; + } + _tmp$6 = ""; + _tmp$7 = false; + value = _tmp$6; + found = _tmp$7; + return [value, found]; + /* */ } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if (!$curGoroutine.asleep) { return [value, found]; } if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: Getenv }; } $f.$ptr = $ptr; $f._entry = _entry; $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.found = found; $f.i = i; $f.i$1 = i$1; $f.key = key; $f.ok = ok; $f.s = s; $f.value = value; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + $pkg.Getenv = Getenv; + msanRead = function(addr, len) { + var $ptr, addr, len; + }; + msanWrite = function(addr, len) { + var $ptr, addr, len; + }; + itoa = function(val) { + var $ptr, val; + if (val < 0) { + return "-" + uitoa((-val >>> 0)); + } + return uitoa((val >>> 0)); + }; + uitoa = function(val) { + var $ptr, _q, _r, buf, i, val; + buf = arrayType$5.zero(); + i = 31; + while (true) { + if (!(val >= 10)) { break; } + ((i < 0 || i >= buf.length) ? $throwRuntimeError("index out of range") : 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") : buf[i] = ((val + 48 >>> 0) << 24 >>> 24)); + return $bytesToString($subslice(new sliceType(buf), i)); + }; + Timespec.ptr.prototype.Unix = function() { + var $ptr, _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 $ptr, 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(); }; + clen = function(n) { + var $ptr, i, n; + i = 0; + while (true) { + if (!(i < n.$length)) { break; } + if (((i < 0 || i >= n.$length) ? $throwRuntimeError("index out of range") : n.$array[n.$offset + i]) === 0) { + return i; + } + i = i + (1) >> 0; + } + return n.$length; + }; + ReadDirent = function(fd, buf) { + var $ptr, _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; + ParseDirent = function(buf, max, names) { + var $ptr, _array, _struct, _tmp, _tmp$1, _tmp$2, _view, buf, bytes, consumed, count, dirent, max, name, names, newnames, origlen, x; + consumed = 0; + count = 0; + newnames = sliceType$1.nil; + origlen = buf.$length; + count = 0; + while (true) { + if (!(!((max === 0)) && buf.$length > 0)) { break; } + dirent = (_array = $sliceToArray(buf), _struct = new Dirent.ptr(new $Uint64(0, 0), new $Int64(0, 0), 0, 0, arrayType$13.zero(), arrayType$14.zero()), _view = new DataView(_array.buffer, _array.byteOffset), _struct.Ino = new $Uint64(_view.getUint32(4, true), _view.getUint32(0, true)), _struct.Off = new $Int64(_view.getUint32(12, true), _view.getUint32(8, true)), _struct.Reclen = _view.getUint16(16, true), _struct.Type = _view.getUint8(18, true), _struct.Name = new ($nativeArray($kindInt8))(_array.buffer, $min(_array.byteOffset + 19, _array.buffer.byteLength)), _struct.Pad_cgo_0 = new ($nativeArray($kindUint8))(_array.buffer, $min(_array.byteOffset + 275, _array.buffer.byteLength)), _struct); + buf = $subslice(buf, dirent.Reclen); + if ((x = dirent.Ino, (x.$high === 0 && x.$low === 0))) { + continue; + } + bytes = $sliceToArray(new sliceType(dirent.Name)); + name = $bytesToString($subslice(new sliceType(bytes), 0, clen(new sliceType(bytes)))); + if (name === "." || name === "..") { + continue; + } + max = max - (1) >> 0; + count = count + (1) >> 0; + names = $append(names, name); + } + _tmp = origlen - buf.$length >> 0; + _tmp$1 = count; + _tmp$2 = names; + consumed = _tmp; + count = _tmp$1; + newnames = _tmp$2; + return [consumed, count, newnames]; + }; + $pkg.ParseDirent = ParseDirent; + mmapper.ptr.prototype.Mmap = function(fd, offset, length, prot, flags) { + var $ptr, _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; $ptr = $f.$ptr; _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; + 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; + 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; + 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.$ptr = $ptr; $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 $ptr, _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; $ptr = $f.$ptr; _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); + 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); + 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; + return err; + } + delete m.active[ptrType$2.keyFor(p)]; + err = $ifaceNil; + 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.$ptr = $ptr; $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 $ptr, e, s; + e = this.$val; + if (0 <= (e >> 0) && (e >> 0) < 133) { + s = ((e < 0 || e >= errors.length) ? $throwRuntimeError("index out of range") : 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 $ptr, e; + e = this.$val; + return (e === 4) || (e === 24) || (e === 104) || (e === 103) || new Errno(e).Timeout(); + }; + $ptrType(Errno).prototype.Temporary = function() { return new Errno(this.$get()).Temporary(); }; + Errno.prototype.Timeout = function() { + var $ptr, 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 $ptr, _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 $ptr, _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$22(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 $ptr, _tuple, err, fd, n, p; + n = 0; + err = $ifaceNil; + if (false) { + race.ReleaseMerge((ioSync$24ptr || (ioSync$24ptr = new ptrType$22(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; + Close = function(fd) { + var $ptr, _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; + Exit = function(code) { + var $ptr, code; + Syscall(231, (code >>> 0), 0, 0); + return; + }; + $pkg.Exit = Exit; + Fchdir = function(fd) { + var $ptr, _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 $ptr, _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; + Fsync = function(fd) { + var $ptr, _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 $ptr, _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 $ptr, _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 $ptr, _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 $ptr, _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 $ptr, _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 $ptr, _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 $ptr, _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; + Lstat = function(path, stat) { + var $ptr, _array, _p0, _struct, _tuple, _tuple$1, _view, e1, err, 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 = Syscall(6, _p0, _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$1[2]; + use(_p0); + if (!((e1 === 0))) { + err = errnoErr(e1); + } + return err; + }; + $pkg.Lstat = Lstat; + Pread = function(fd, p, offset) { + var $ptr, _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 $ptr, _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 $ptr, _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; + mmap = function(addr, length, prot, flags, fd, offset) { + var $ptr, _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: "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$29.methods = [{prop: "Unix", name: "Unix", pkg: "", typ: $funcType([], [$Int64, $Int64], false)}, {prop: "Nano", name: "Nano", pkg: "", typ: $funcType([], [$Int64], false)}]; + mmapper.init([{prop: "Mutex", name: "", pkg: "", typ: sync.Mutex, tag: ""}, {prop: "active", name: "active", pkg: "syscall", typ: mapType, tag: ""}, {prop: "mmap", name: "mmap", pkg: "syscall", typ: funcType, tag: ""}, {prop: "munmap", name: "munmap", pkg: "syscall", typ: funcType$1, tag: ""}]); + Timespec.init([{prop: "Sec", name: "Sec", pkg: "", typ: $Int64, tag: ""}, {prop: "Nsec", name: "Nsec", pkg: "", typ: $Int64, tag: ""}]); + Stat_t.init([{prop: "Dev", name: "Dev", pkg: "", typ: $Uint64, tag: ""}, {prop: "Ino", name: "Ino", pkg: "", typ: $Uint64, tag: ""}, {prop: "Nlink", name: "Nlink", pkg: "", typ: $Uint64, tag: ""}, {prop: "Mode", name: "Mode", pkg: "", typ: $Uint32, tag: ""}, {prop: "Uid", name: "Uid", pkg: "", typ: $Uint32, tag: ""}, {prop: "Gid", name: "Gid", pkg: "", typ: $Uint32, tag: ""}, {prop: "X__pad0", name: "X__pad0", pkg: "", typ: $Int32, tag: ""}, {prop: "Rdev", name: "Rdev", pkg: "", typ: $Uint64, tag: ""}, {prop: "Size", name: "Size", pkg: "", typ: $Int64, tag: ""}, {prop: "Blksize", name: "Blksize", pkg: "", typ: $Int64, tag: ""}, {prop: "Blocks", name: "Blocks", pkg: "", typ: $Int64, tag: ""}, {prop: "Atim", name: "Atim", pkg: "", typ: Timespec, tag: ""}, {prop: "Mtim", name: "Mtim", pkg: "", typ: Timespec, tag: ""}, {prop: "Ctim", name: "Ctim", pkg: "", typ: Timespec, tag: ""}, {prop: "X__unused", name: "X__unused", pkg: "", typ: arrayType$18, tag: ""}]); + Dirent.init([{prop: "Ino", name: "Ino", pkg: "", typ: $Uint64, tag: ""}, {prop: "Off", name: "Off", pkg: "", typ: $Int64, tag: ""}, {prop: "Reclen", name: "Reclen", pkg: "", typ: $Uint16, tag: ""}, {prop: "Type", name: "Type", pkg: "", typ: $Uint8, tag: ""}, {prop: "Name", name: "Name", pkg: "", typ: arrayType$13, tag: ""}, {prop: "Pad_cgo_0", name: "Pad_cgo_0", pkg: "", typ: arrayType$14, 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; + envOnce = new sync.Once.ptr(new sync.Mutex.ptr(0, 0), 0); + envLock = new sync.RWMutex.ptr(new sync.Mutex.ptr(0, 0), 0, 0, 0, 0); + env = false; + 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, RWMutex, WaitGroup, Once, ptrType$1, ptrType$2, funcType, ptrType$3; + RWMutex = $pkg.RWMutex = $newType(0, $kindStruct, "nosync.RWMutex", "RWMutex", "github.com/gopherjs/gopherjs/nosync", function(writeLocked_, readLockCounter_) { + this.$val = this; + if (arguments.length === 0) { + this.writeLocked = false; + this.readLockCounter = 0; + return; + } + this.writeLocked = writeLocked_; + this.readLockCounter = readLockCounter_; + }); + WaitGroup = $pkg.WaitGroup = $newType(0, $kindStruct, "nosync.WaitGroup", "WaitGroup", "github.com/gopherjs/gopherjs/nosync", function(counter_) { + this.$val = this; + if (arguments.length === 0) { + this.counter = 0; + return; + } + this.counter = counter_; + }); + Once = $pkg.Once = $newType(0, $kindStruct, "nosync.Once", "Once", "github.com/gopherjs/gopherjs/nosync", function(doing_, done_) { + this.$val = this; + if (arguments.length === 0) { + this.doing = false; + this.done = false; + return; + } + this.doing = doing_; + this.done = done_; + }); + ptrType$1 = $ptrType(RWMutex); + ptrType$2 = $ptrType(WaitGroup); + funcType = $funcType([], [], false); + ptrType$3 = $ptrType(Once); + RWMutex.ptr.prototype.Lock = function() { + var $ptr, rw; + rw = this; + if (!((rw.readLockCounter === 0)) || rw.writeLocked) { + $panic(new $String("nosync: mutex is already locked")); + } + rw.writeLocked = true; + }; + RWMutex.prototype.Lock = function() { return this.$val.Lock(); }; + RWMutex.ptr.prototype.Unlock = function() { + var $ptr, rw; + rw = this; + if (!rw.writeLocked) { + $panic(new $String("nosync: unlock of unlocked mutex")); + } + rw.writeLocked = false; + }; + RWMutex.prototype.Unlock = function() { return this.$val.Unlock(); }; + RWMutex.ptr.prototype.RLock = function() { + var $ptr, rw; + rw = this; + if (rw.writeLocked) { + $panic(new $String("nosync: mutex is already locked")); + } + rw.readLockCounter = rw.readLockCounter + (1) >> 0; + }; + RWMutex.prototype.RLock = function() { return this.$val.RLock(); }; + RWMutex.ptr.prototype.RUnlock = function() { + var $ptr, rw; + rw = this; + if (rw.readLockCounter === 0) { + $panic(new $String("nosync: unlock of unlocked mutex")); + } + rw.readLockCounter = rw.readLockCounter - (1) >> 0; + }; + RWMutex.prototype.RUnlock = function() { return this.$val.RUnlock(); }; + WaitGroup.ptr.prototype.Add = function(delta) { + var $ptr, 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 $ptr, wg; + wg = this; + wg.Add(-1); + }; + WaitGroup.prototype.Done = function() { return this.$val.Done(); }; + WaitGroup.ptr.prototype.Wait = function() { + var $ptr, 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 $ptr, f, o, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; 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) { + return; + } + if (o[0].doing) { + $panic(new $String("nosync: Do called within f")); + } + o[0].doing = true; + $deferred.push([(function(o) { return function() { + var $ptr; + 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; case -1: } return; } } catch(err) { $err = err; $s = -1; } finally { $callDeferred($deferred, $err); if($curGoroutine.asleep) { if ($f === undefined) { $f = { $blk: Once.ptr.prototype.Do }; } $f.$ptr = $ptr; $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); }; + ptrType$1.methods = [{prop: "Lock", name: "Lock", pkg: "", typ: $funcType([], [], false)}, {prop: "Unlock", name: "Unlock", pkg: "", typ: $funcType([], [], false)}, {prop: "RLock", name: "RLock", pkg: "", typ: $funcType([], [], false)}, {prop: "RUnlock", name: "RUnlock", pkg: "", typ: $funcType([], [], false)}]; + ptrType$2.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$3.methods = [{prop: "Do", name: "Do", pkg: "", typ: $funcType([funcType], [], false)}]; + RWMutex.init([{prop: "writeLocked", name: "writeLocked", pkg: "github.com/gopherjs/gopherjs/nosync", typ: $Bool, tag: ""}, {prop: "readLockCounter", name: "readLockCounter", pkg: "github.com/gopherjs/gopherjs/nosync", typ: $Int, tag: ""}]); + WaitGroup.init([{prop: "counter", name: "counter", pkg: "github.com/gopherjs/gopherjs/nosync", typ: $Int, tag: ""}]); + Once.init([{prop: "doing", name: "doing", pkg: "github.com/gopherjs/gopherjs/nosync", typ: $Bool, tag: ""}, {prop: "done", name: "done", pkg: "github.com/gopherjs/gopherjs/nosync", 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: + /* */ } 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, io, unicode, utf8, IndexByte, Index, ContainsRune, IndexRune; + errors = $packages["errors"]; + js = $packages["github.com/gopherjs/gopherjs/js"]; + io = $packages["io"]; + unicode = $packages["unicode"]; + utf8 = $packages["unicode/utf8"]; + IndexByte = function(s, c) { + var $ptr, c, s; + return $parseInt(s.indexOf($global.String.fromCharCode(c))) >> 0; + }; + $pkg.IndexByte = IndexByte; + Index = function(s, sep) { + var $ptr, s, sep; + return $parseInt(s.indexOf(sep)) >> 0; + }; + $pkg.Index = Index; + ContainsRune = function(s, r) { + var $ptr, r, s; + return IndexRune(s, r) >= 0; + }; + $pkg.ContainsRune = ContainsRune; + IndexRune = function(s, r) { + var $ptr, _i, _ref, _rune, c, i, r, s; + if (r < 128) { + return IndexByte(s, (r << 24 >>> 24)); + } else { + _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; + }; + $pkg.IndexRune = IndexRune; + $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 = 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; } + /* */ } 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, strings, syscall, ParseError, Time, Month, Weekday, Duration, Location, zone, zoneTrans, sliceType, sliceType$1, ptrType, sliceType$2, arrayType, sliceType$3, arrayType$1, arrayType$2, ptrType$1, arrayType$4, ptrType$3, ptrType$6, std0x, longDayNames, shortDayNames, shortMonthNames, longMonthNames, atoiError, errBad, errLeadingInt, unitMap, months, days, daysBefore, utcLoc, utcLoc$24ptr, localLoc, localLoc$24ptr, localOnce, zoneinfo, badData, zoneDirs, _tuple, _r, init, initLocal, startsWithLowerCase, nextStdChunk, match, lookup, appendInt, atoi, formatNano, quote, isDigit, getnum, cutspace, skip, Parse, parse, parseTimeZone, parseGMT, parseNanoseconds, leadingInt, ParseDuration, absWeekday, absClock, fmtFrac, fmtInt, absDate, daysIn, 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"]; + strings = $packages["strings"]; + syscall = $packages["syscall"]; + ParseError = $pkg.ParseError = $newType(0, $kindStruct, "time.ParseError", "ParseError", "time", 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", "Time", "time", function(sec_, nsec_, loc_) { + this.$val = this; + if (arguments.length === 0) { + this.sec = new $Int64(0, 0); + this.nsec = 0; + this.loc = ptrType$1.nil; + return; + } + this.sec = sec_; + this.nsec = nsec_; + this.loc = loc_; + }); + Month = $pkg.Month = $newType(4, $kindInt, "time.Month", "Month", "time", null); + Weekday = $pkg.Weekday = $newType(4, $kindInt, "time.Weekday", "Weekday", "time", null); + Duration = $pkg.Duration = $newType(8, $kindInt64, "time.Duration", "Duration", "time", null); + Location = $pkg.Location = $newType(0, $kindStruct, "time.Location", "Location", "time", 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", "zone", "time", 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", "zoneTrans", "time", 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$1 = $ptrType(Location); + arrayType$4 = $arrayType($Uint8, 32); + ptrType$3 = $ptrType(ParseError); + ptrType$6 = $ptrType(Time); + init = function() { + var $ptr; + Unix(new $Int64(0, 0), new $Int64(0, 0)); + }; + initLocal = function() { + var $ptr, d, i, j, s; + d = new ($global.Date)(); + s = $internalize(d, $String); + i = strings.IndexByte(s, 40); + j = strings.IndexByte(s, 41); + if ((i === -1) || (j === -1)) { + localLoc.name = "UTC"; + return; + } + localLoc.name = s.substring((i + 1 >> 0), j); + localLoc.zone = new sliceType([new zone.ptr(localLoc.name, $imul(($parseInt(d.getTimezoneOffset()) >> 0), -60), false)]); + }; + startsWithLowerCase = function(str) { + var $ptr, c, str; + if (str.length === 0) { + return false; + } + c = str.charCodeAt(0); + return 97 <= c && c <= 122; + }; + nextStdChunk = function(layout) { + var $ptr, _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; + 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) && layout.substring(i, (i + 3 >> 0)) === "Jan") { + if (layout.length >= (i + 7 >> 0) && layout.substring(i, (i + 7 >> 0)) === "January") { + _tmp = layout.substring(0, i); + _tmp$1 = 257; + _tmp$2 = layout.substring((i + 7 >> 0)); + prefix = _tmp; + std = _tmp$1; + suffix = _tmp$2; + return [prefix, std, suffix]; + } + if (!startsWithLowerCase(layout.substring((i + 3 >> 0)))) { + _tmp$3 = layout.substring(0, i); + _tmp$4 = 258; + _tmp$5 = layout.substring((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 (layout.substring(i, (i + 3 >> 0)) === "Mon") { + if (layout.length >= (i + 6 >> 0) && layout.substring(i, (i + 6 >> 0)) === "Monday") { + _tmp$6 = layout.substring(0, i); + _tmp$7 = 261; + _tmp$8 = layout.substring((i + 6 >> 0)); + prefix = _tmp$6; + std = _tmp$7; + suffix = _tmp$8; + return [prefix, std, suffix]; + } + if (!startsWithLowerCase(layout.substring((i + 3 >> 0)))) { + _tmp$9 = layout.substring(0, i); + _tmp$10 = 262; + _tmp$11 = layout.substring((i + 3 >> 0)); + prefix = _tmp$9; + std = _tmp$10; + suffix = _tmp$11; + return [prefix, std, suffix]; + } + } + if (layout.substring(i, (i + 3 >> 0)) === "MST") { + _tmp$12 = layout.substring(0, i); + _tmp$13 = 21; + _tmp$14 = layout.substring((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 = layout.substring(0, i); + _tmp$16 = (x = layout.charCodeAt((i + 1 >> 0)) - 49 << 24 >>> 24, ((x < 0 || x >= std0x.length) ? $throwRuntimeError("index out of range") : std0x[x])); + _tmp$17 = layout.substring((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 = layout.substring(0, i); + _tmp$19 = 522; + _tmp$20 = layout.substring((i + 2 >> 0)); + prefix = _tmp$18; + std = _tmp$19; + suffix = _tmp$20; + return [prefix, std, suffix]; + } + _tmp$21 = layout.substring(0, i); + _tmp$22 = 259; + _tmp$23 = layout.substring((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) && layout.substring(i, (i + 4 >> 0)) === "2006") { + _tmp$24 = layout.substring(0, i); + _tmp$25 = 273; + _tmp$26 = layout.substring((i + 4 >> 0)); + prefix = _tmp$24; + std = _tmp$25; + suffix = _tmp$26; + return [prefix, std, suffix]; + } + _tmp$27 = layout.substring(0, i); + _tmp$28 = 263; + _tmp$29 = layout.substring((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) && layout.substring((i + 1 >> 0), (i + 5 >> 0)) === "2006") { + _tmp$30 = layout.substring(0, (i + 1 >> 0)); + _tmp$31 = 273; + _tmp$32 = layout.substring((i + 5 >> 0)); + prefix = _tmp$30; + std = _tmp$31; + suffix = _tmp$32; + return [prefix, std, suffix]; + } + _tmp$33 = layout.substring(0, i); + _tmp$34 = 264; + _tmp$35 = layout.substring((i + 2 >> 0)); + prefix = _tmp$33; + std = _tmp$34; + suffix = _tmp$35; + return [prefix, std, suffix]; + } + } else if (_1 === (51)) { + _tmp$36 = layout.substring(0, i); + _tmp$37 = 523; + _tmp$38 = layout.substring((i + 1 >> 0)); + prefix = _tmp$36; + std = _tmp$37; + suffix = _tmp$38; + return [prefix, std, suffix]; + } else if (_1 === (52)) { + _tmp$39 = layout.substring(0, i); + _tmp$40 = 525; + _tmp$41 = layout.substring((i + 1 >> 0)); + prefix = _tmp$39; + std = _tmp$40; + suffix = _tmp$41; + return [prefix, std, suffix]; + } else if (_1 === (53)) { + _tmp$42 = layout.substring(0, i); + _tmp$43 = 527; + _tmp$44 = layout.substring((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 = layout.substring(0, i); + _tmp$46 = 531; + _tmp$47 = layout.substring((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 = layout.substring(0, i); + _tmp$49 = 532; + _tmp$50 = layout.substring((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) && layout.substring(i, (i + 7 >> 0)) === "-070000") { + _tmp$51 = layout.substring(0, i); + _tmp$52 = 28; + _tmp$53 = layout.substring((i + 7 >> 0)); + prefix = _tmp$51; + std = _tmp$52; + suffix = _tmp$53; + return [prefix, std, suffix]; + } + if (layout.length >= (i + 9 >> 0) && layout.substring(i, (i + 9 >> 0)) === "-07:00:00") { + _tmp$54 = layout.substring(0, i); + _tmp$55 = 31; + _tmp$56 = layout.substring((i + 9 >> 0)); + prefix = _tmp$54; + std = _tmp$55; + suffix = _tmp$56; + return [prefix, std, suffix]; + } + if (layout.length >= (i + 5 >> 0) && layout.substring(i, (i + 5 >> 0)) === "-0700") { + _tmp$57 = layout.substring(0, i); + _tmp$58 = 27; + _tmp$59 = layout.substring((i + 5 >> 0)); + prefix = _tmp$57; + std = _tmp$58; + suffix = _tmp$59; + return [prefix, std, suffix]; + } + if (layout.length >= (i + 6 >> 0) && layout.substring(i, (i + 6 >> 0)) === "-07:00") { + _tmp$60 = layout.substring(0, i); + _tmp$61 = 30; + _tmp$62 = layout.substring((i + 6 >> 0)); + prefix = _tmp$60; + std = _tmp$61; + suffix = _tmp$62; + return [prefix, std, suffix]; + } + if (layout.length >= (i + 3 >> 0) && layout.substring(i, (i + 3 >> 0)) === "-07") { + _tmp$63 = layout.substring(0, i); + _tmp$64 = 29; + _tmp$65 = layout.substring((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) && layout.substring(i, (i + 7 >> 0)) === "Z070000") { + _tmp$66 = layout.substring(0, i); + _tmp$67 = 23; + _tmp$68 = layout.substring((i + 7 >> 0)); + prefix = _tmp$66; + std = _tmp$67; + suffix = _tmp$68; + return [prefix, std, suffix]; + } + if (layout.length >= (i + 9 >> 0) && layout.substring(i, (i + 9 >> 0)) === "Z07:00:00") { + _tmp$69 = layout.substring(0, i); + _tmp$70 = 26; + _tmp$71 = layout.substring((i + 9 >> 0)); + prefix = _tmp$69; + std = _tmp$70; + suffix = _tmp$71; + return [prefix, std, suffix]; + } + if (layout.length >= (i + 5 >> 0) && layout.substring(i, (i + 5 >> 0)) === "Z0700") { + _tmp$72 = layout.substring(0, i); + _tmp$73 = 22; + _tmp$74 = layout.substring((i + 5 >> 0)); + prefix = _tmp$72; + std = _tmp$73; + suffix = _tmp$74; + return [prefix, std, suffix]; + } + if (layout.length >= (i + 6 >> 0) && layout.substring(i, (i + 6 >> 0)) === "Z07:00") { + _tmp$75 = layout.substring(0, i); + _tmp$76 = 25; + _tmp$77 = layout.substring((i + 6 >> 0)); + prefix = _tmp$75; + std = _tmp$76; + suffix = _tmp$77; + return [prefix, std, suffix]; + } + if (layout.length >= (i + 3 >> 0) && layout.substring(i, (i + 3 >> 0)) === "Z07") { + _tmp$78 = layout.substring(0, i); + _tmp$79 = 24; + _tmp$80 = layout.substring((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 = layout.substring(0, i); + _tmp$82 = std$1; + _tmp$83 = layout.substring(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 $ptr, 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 $ptr, _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") : _ref.$array[_ref.$offset + _i]); + if (val.length >= v.length && match(val.substring(0, v.length), v)) { + return [i, val.substring(v.length), $ifaceNil]; + } + _i++; + } + return [-1, val, errBad]; + }; + appendInt = function(b, x, width) { + var $ptr, _q, b, buf, i, q, u, w, width, x; + u = (x >>> 0); + if (x < 0) { + b = $append(b, 45); + u = (-x >>> 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") : 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") : 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 $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple$1, err, neg, q, rem, s, x; + x = 0; + err = $ifaceNil; + neg = false; + if (!(s === "") && ((s.charCodeAt(0) === 45) || (s.charCodeAt(0) === 43))) { + neg = s.charCodeAt(0) === 45; + s = s.substring(1); + } + _tuple$1 = leadingInt(s); + q = _tuple$1[0]; + rem = _tuple$1[1]; + err = _tuple$1[2]; + x = ((q.$low + ((q.$high >> 31) * 4294967296)) >> 0); + if (!($interfaceIsEqual(err, $ifaceNil)) || !(rem === "")) { + _tmp = 0; + _tmp$1 = atoiError; + x = _tmp; + err = _tmp$1; + return [x, err]; + } + if (neg) { + x = -x; + } + _tmp$2 = x; + _tmp$3 = $ifaceNil; + x = _tmp$2; + err = _tmp$3; + return [x, err]; + }; + formatNano = function(b, nanosec, n, trim) { + var $ptr, _q, _r$1, b, buf, n, nanosec, start, trim, u, x; + 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") : buf[start] = (((_r$1 = u % 10, _r$1 === _r$1 ? _r$1 : $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 = n - 1 >> 0, ((x < 0 || x >= buf.length) ? $throwRuntimeError("index out of range") : buf[x])) === 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 $ptr, _r$1, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = $clone(this, Time); + _r$1 = t.Format("2006-01-02 15:04:05.999999999 -0700 MST"); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + /* */ $s = 2; case 2: + return _r$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.String }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.String = function() { return this.$val.String(); }; + Time.ptr.prototype.Format = function(layout) { + var $ptr, _r$1, b, buf, layout, max, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; 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 = $clone(this, Time); + 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$1 = t.AppendFormat(b, layout); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + b = _r$1; + return $bytesToString(b); + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.Format }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $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 $ptr, _2, _q, _q$1, _q$2, _q$3, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _tuple$1, _tuple$2, _tuple$3, _tuple$4, 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; $ptr = $f.$ptr; _2 = $f._2; _q = $f._q; _q$1 = $f._q$1; _q$2 = $f._q$2; _q$3 = $f._q$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$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; _tuple$3 = $f._tuple$3; _tuple$4 = $f._tuple$4; 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 = $clone(this, Time); + _r$1 = t.locabs(); /* */ $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; + name = _tuple$1[0]; + offset = _tuple$1[1]; + abs = _tuple$1[2]; + year = -1; + month = 0; + day = 0; + hour = -1; + min = 0; + sec = 0; + while (true) { + if (!(!(layout === ""))) { break; } + _tuple$2 = nextStdChunk(layout); + prefix = _tuple$2[0]; + std = _tuple$2[1]; + suffix = _tuple$2[2]; + if (!(prefix === "")) { + b = $appendSlice(b, prefix); + } + if (std === 0) { + break; + } + layout = suffix; + if (year < 0 && !(((std & 256) === 0))) { + _tuple$3 = absDate(abs, true); + year = _tuple$3[0]; + month = _tuple$3[1]; + day = _tuple$3[2]; + } + if (hour < 0 && !(((std & 512) === 0))) { + _tuple$4 = absClock(abs); + hour = _tuple$4[0]; + min = _tuple$4[1]; + sec = _tuple$4[2]; + } + switch (0) { default: + _2 = std & 65535; + if (_2 === (274)) { + y = year; + if (y < 0) { + y = -y; + } + b = appendInt(b, (_r$2 = y % 100, _r$2 === _r$2 ? _r$2 : $throwRuntimeError("integer divide by zero")), 2); + } else if (_2 === (273)) { + b = appendInt(b, year, 4); + } else if (_2 === (258)) { + b = $appendSlice(b, new Month(month).String().substring(0, 3)); + } else if (_2 === (257)) { + m = new Month(month).String(); + b = $appendSlice(b, m); + } else if (_2 === (259)) { + b = appendInt(b, (month >> 0), 0); + } else if (_2 === (260)) { + b = appendInt(b, (month >> 0), 2); + } else if (_2 === (262)) { + b = $appendSlice(b, new Weekday(absWeekday(abs)).String().substring(0, 3)); + } else if (_2 === (261)) { + s = new Weekday(absWeekday(abs)).String(); + b = $appendSlice(b, s); + } else if (_2 === (263)) { + b = appendInt(b, day, 0); + } else if (_2 === (264)) { + if (day < 10) { + b = $append(b, 32); + } + b = appendInt(b, day, 0); + } else if (_2 === (265)) { + b = appendInt(b, day, 2); + } else if (_2 === (522)) { + b = appendInt(b, hour, 2); + } else if (_2 === (523)) { + hr = (_r$3 = hour % 12, _r$3 === _r$3 ? _r$3 : $throwRuntimeError("integer divide by zero")); + if (hr === 0) { + hr = 12; + } + b = appendInt(b, hr, 0); + } else if (_2 === (524)) { + hr$1 = (_r$4 = hour % 12, _r$4 === _r$4 ? _r$4 : $throwRuntimeError("integer divide by zero")); + if (hr$1 === 0) { + hr$1 = 12; + } + b = appendInt(b, hr$1, 2); + } else if (_2 === (525)) { + b = appendInt(b, min, 0); + } else if (_2 === (526)) { + b = appendInt(b, min, 2); + } else if (_2 === (527)) { + b = appendInt(b, sec, 0); + } else if (_2 === (528)) { + b = appendInt(b, sec, 2); + } else if (_2 === (531)) { + if (hour >= 12) { + b = $appendSlice(b, "PM"); + } else { + b = $appendSlice(b, "AM"); + } + } else if (_2 === (532)) { + if (hour >= 12) { + b = $appendSlice(b, "pm"); + } else { + b = $appendSlice(b, "am"); + } + } else if ((_2 === (22)) || (_2 === (25)) || (_2 === (23)) || (_2 === (24)) || (_2 === (26)) || (_2 === (27)) || (_2 === (30)) || (_2 === (28)) || (_2 === (29)) || (_2 === (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$5 = zone$1 % 60, _r$5 === _r$5 ? _r$5 : $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$6 = absoffset % 60, _r$6 === _r$6 ? _r$6 : $throwRuntimeError("integer divide by zero")), 2); + } + } else if (_2 === (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$7 = zone$2 % 60, _r$7 === _r$7 ? _r$7 : $throwRuntimeError("integer divide by zero")), 2); + } else if ((_2 === (32)) || (_2 === (33))) { + b = formatNano(b, (t.Nanosecond() >>> 0), std >> 16 >> 0, (std & 65535) === 33); + } + } + } + return b; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.AppendFormat }; } $f.$ptr = $ptr; $f._2 = _2; $f._q = _q; $f._q$1 = _q$1; $f._q$2 = _q$2; $f._q$3 = _q$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$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f._tuple$3 = _tuple$3; $f._tuple$4 = _tuple$4; $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 $ptr, s; + return "\"" + s + "\""; + }; + ParseError.ptr.prototype.Error = function() { + var $ptr, 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 $ptr, c, i, s; + if (s.length <= i) { + return false; + } + c = s.charCodeAt(i); + return 48 <= c && c <= 57; + }; + getnum = function(s, fixed) { + var $ptr, 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), s.substring(1), $ifaceNil]; + } + return [($imul(((s.charCodeAt(0) - 48 << 24 >>> 24) >> 0), 10)) + ((s.charCodeAt(1) - 48 << 24 >>> 24) >> 0) >> 0, s.substring(2), $ifaceNil]; + }; + cutspace = function(s) { + var $ptr, s; + while (true) { + if (!(s.length > 0 && (s.charCodeAt(0) === 32))) { break; } + s = s.substring(1); + } + return s; + }; + skip = function(value, prefix) { + var $ptr, 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 = prefix.substring(1); + value = value.substring(1); + } + return [value, $ifaceNil]; + }; + Parse = function(layout, value) { + var $ptr, _r$1, layout, value, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; layout = $f.layout; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r$1 = parse(layout, value, $pkg.UTC, $pkg.Local); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + /* */ $s = 2; case 2: + return _r$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: Parse }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f.layout = layout; $f.value = value; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.Parse = Parse; + parse = function(layout, value, defaultLocation, local) { + var $ptr, _3, _4, _5, _6, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _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$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$25, _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, x$1, x$2, x$3, x$4, x$5, year, z, zoneName, zoneOffset, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _3 = $f._3; _4 = $f._4; _5 = $f._5; _6 = $f._6; _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; _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$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$25 = $f._tuple$25; _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 = $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; 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$1.nil; + zoneOffset = -1; + zoneName = ""; + while (true) { + err = $ifaceNil; + _tuple$1 = nextStdChunk(layout); + prefix = _tuple$1[0]; + std = _tuple$1[1]; + suffix = _tuple$1[2]; + stdstr = layout.substring(prefix.length, (layout.length - suffix.length >> 0)); + _tuple$2 = skip(value, prefix); + value = _tuple$2[0]; + err = _tuple$2[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + return [new Time.ptr(new $Int64(0, 0), 0, ptrType$1.nil), new ParseError.ptr(alayout, avalue, prefix, value, "")]; + } + if (std === 0) { + if (!((value.length === 0))) { + return [new Time.ptr(new $Int64(0, 0), 0, ptrType$1.nil), new ParseError.ptr(alayout, avalue, "", value, ": extra text: " + value)]; + } + break; + } + layout = suffix; + p = ""; + switch (0) { default: + _3 = std & 65535; + if (_3 === (274)) { + if (value.length < 2) { + err = errBad; + break; + } + _tmp$2 = value.substring(0, 2); + _tmp$3 = value.substring(2); + p = _tmp$2; + value = _tmp$3; + _tuple$3 = atoi(p); + year = _tuple$3[0]; + err = _tuple$3[1]; + if (year >= 69) { + year = year + (1900) >> 0; + } else { + year = year + (2000) >> 0; + } + } else if (_3 === (273)) { + if (value.length < 4 || !isDigit(value, 0)) { + err = errBad; + break; + } + _tmp$4 = value.substring(0, 4); + _tmp$5 = value.substring(4); + p = _tmp$4; + value = _tmp$5; + _tuple$4 = atoi(p); + year = _tuple$4[0]; + err = _tuple$4[1]; + } else if (_3 === (258)) { + _tuple$5 = lookup(shortMonthNames, value); + month = _tuple$5[0]; + value = _tuple$5[1]; + err = _tuple$5[2]; + } else if (_3 === (257)) { + _tuple$6 = lookup(longMonthNames, value); + month = _tuple$6[0]; + value = _tuple$6[1]; + err = _tuple$6[2]; + } else if ((_3 === (259)) || (_3 === (260))) { + _tuple$7 = getnum(value, std === 260); + month = _tuple$7[0]; + value = _tuple$7[1]; + err = _tuple$7[2]; + if (month <= 0 || 12 < month) { + rangeErrString = "month"; + } + } else if (_3 === (262)) { + _tuple$8 = lookup(shortDayNames, value); + value = _tuple$8[1]; + err = _tuple$8[2]; + } else if (_3 === (261)) { + _tuple$9 = lookup(longDayNames, value); + value = _tuple$9[1]; + err = _tuple$9[2]; + } else if ((_3 === (263)) || (_3 === (264)) || (_3 === (265))) { + if ((std === 264) && value.length > 0 && (value.charCodeAt(0) === 32)) { + value = value.substring(1); + } + _tuple$10 = getnum(value, std === 265); + day = _tuple$10[0]; + value = _tuple$10[1]; + err = _tuple$10[2]; + if (day < 0) { + rangeErrString = "day"; + } + } else if (_3 === (522)) { + _tuple$11 = getnum(value, false); + hour = _tuple$11[0]; + value = _tuple$11[1]; + err = _tuple$11[2]; + if (hour < 0 || 24 <= hour) { + rangeErrString = "hour"; + } + } else if ((_3 === (523)) || (_3 === (524))) { + _tuple$12 = getnum(value, std === 524); + hour = _tuple$12[0]; + value = _tuple$12[1]; + err = _tuple$12[2]; + if (hour < 0 || 12 < hour) { + rangeErrString = "hour"; + } + } else if ((_3 === (525)) || (_3 === (526))) { + _tuple$13 = getnum(value, std === 526); + min = _tuple$13[0]; + value = _tuple$13[1]; + err = _tuple$13[2]; + if (min < 0 || 60 <= min) { + rangeErrString = "minute"; + } + } else if ((_3 === (527)) || (_3 === (528))) { + _tuple$14 = getnum(value, std === 528); + sec = _tuple$14[0]; + value = _tuple$14[1]; + err = _tuple$14[2]; + if (sec < 0 || 60 <= sec) { + rangeErrString = "second"; + } + if (value.length >= 2 && (value.charCodeAt(0) === 46) && isDigit(value, 1)) { + _tuple$15 = nextStdChunk(layout); + std = _tuple$15[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$16 = parseNanoseconds(value, n); + nsec = _tuple$16[0]; + rangeErrString = _tuple$16[1]; + err = _tuple$16[2]; + value = value.substring(n); + } + } else if (_3 === (531)) { + if (value.length < 2) { + err = errBad; + break; + } + _tmp$6 = value.substring(0, 2); + _tmp$7 = value.substring(2); + p = _tmp$6; + value = _tmp$7; + _4 = p; + if (_4 === ("PM")) { + pmSet = true; + } else if (_4 === ("AM")) { + amSet = true; + } else { + err = errBad; + } + } else if (_3 === (532)) { + if (value.length < 2) { + err = errBad; + break; + } + _tmp$8 = value.substring(0, 2); + _tmp$9 = value.substring(2); + p = _tmp$8; + value = _tmp$9; + _5 = p; + if (_5 === ("pm")) { + pmSet = true; + } else if (_5 === ("am")) { + amSet = true; + } else { + err = errBad; + } + } else if ((_3 === (22)) || (_3 === (25)) || (_3 === (23)) || (_3 === (24)) || (_3 === (26)) || (_3 === (27)) || (_3 === (29)) || (_3 === (30)) || (_3 === (28)) || (_3 === (31))) { + if (((std === 22) || (std === 24) || (std === 25)) && value.length >= 1 && (value.charCodeAt(0) === 90)) { + value = value.substring(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 = value.substring(0, 1); + _tmp$15 = value.substring(1, 3); + _tmp$16 = value.substring(4, 6); + _tmp$17 = "00"; + _tmp$18 = value.substring(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 = value.substring(0, 1); + _tmp$20 = value.substring(1, 3); + _tmp$21 = "00"; + _tmp$22 = "00"; + _tmp$23 = value.substring(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 = value.substring(0, 1); + _tmp$25 = value.substring(1, 3); + _tmp$26 = value.substring(4, 6); + _tmp$27 = value.substring(7, 9); + _tmp$28 = value.substring(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 = value.substring(0, 1); + _tmp$30 = value.substring(1, 3); + _tmp$31 = value.substring(3, 5); + _tmp$32 = value.substring(5, 7); + _tmp$33 = value.substring(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 = value.substring(0, 1); + _tmp$35 = value.substring(1, 3); + _tmp$36 = value.substring(3, 5); + _tmp$37 = "00"; + _tmp$38 = value.substring(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$17 = atoi(hour$1); + hr = _tuple$17[0]; + err = _tuple$17[1]; + if ($interfaceIsEqual(err, $ifaceNil)) { + _tuple$18 = atoi(min$1); + mm = _tuple$18[0]; + err = _tuple$18[1]; + } + if ($interfaceIsEqual(err, $ifaceNil)) { + _tuple$19 = atoi(seconds); + ss = _tuple$19[0]; + err = _tuple$19[1]; + } + zoneOffset = ($imul(((($imul(hr, 60)) + mm >> 0)), 60)) + ss >> 0; + _6 = sign.charCodeAt(0); + if (_6 === (43)) { + } else if (_6 === (45)) { + zoneOffset = -zoneOffset; + } else { + err = errBad; + } + } else if (_3 === (21)) { + if (value.length >= 3 && value.substring(0, 3) === "UTC") { + z = $pkg.UTC; + value = value.substring(3); + break; + } + _tuple$20 = parseTimeZone(value); + n$1 = _tuple$20[0]; + ok = _tuple$20[1]; + if (!ok) { + err = errBad; + break; + } + _tmp$42 = value.substring(0, n$1); + _tmp$43 = value.substring(n$1); + zoneName = _tmp$42; + value = _tmp$43; + } else if (_3 === (32)) { + ndigit = 1 + ((std >> 16 >> 0)) >> 0; + if (value.length < ndigit) { + err = errBad; + break; + } + _tuple$21 = parseNanoseconds(value, ndigit); + nsec = _tuple$21[0]; + rangeErrString = _tuple$21[1]; + err = _tuple$21[2]; + value = value.substring(ndigit); + } else if (_3 === (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$22 = parseNanoseconds(value, 1 + i >> 0); + nsec = _tuple$22[0]; + rangeErrString = _tuple$22[1]; + err = _tuple$22[2]; + value = value.substring((1 + i >> 0)); + } + } + if (!(rangeErrString === "")) { + return [new Time.ptr(new $Int64(0, 0), 0, ptrType$1.nil), new ParseError.ptr(alayout, avalue, stdstr, value, ": " + rangeErrString + " out of range")]; + } + if (!($interfaceIsEqual(err, $ifaceNil))) { + return [new Time.ptr(new $Int64(0, 0), 0, ptrType$1.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 > daysIn((month >> 0), year)) { + return [new Time.ptr(new $Int64(0, 0), 0, ptrType$1.nil), new ParseError.ptr(alayout, avalue, "", value, ": day out of range")]; + } + /* */ if (!(z === ptrType$1.nil)) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (!(z === ptrType$1.nil)) { */ case 1: + _r$1 = Date(year, (month >> 0), day, hour, min, sec, nsec, z); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + /* */ $s = 4; case 4: + return [_r$1, $ifaceNil]; + /* } */ case 2: + /* */ if (!((zoneOffset === -1))) { $s = 5; continue; } + /* */ $s = 6; continue; + /* if (!((zoneOffset === -1))) { */ case 5: + _r$2 = Date(year, (month >> 0), day, hour, min, sec, nsec, $pkg.UTC); /* */ $s = 7; case 7: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + t = $clone(_r$2, Time); + t.sec = (x = t.sec, x$1 = new $Int64(0, zoneOffset), new $Int64(x.$high - x$1.$high, x.$low - x$1.$low)); + _r$3 = local.lookup((x$2 = t.sec, new $Int64(x$2.$high + -15, x$2.$low + 2288912640))); /* */ $s = 8; case 8: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _tuple$23 = _r$3; + name = _tuple$23[0]; + offset = _tuple$23[1]; + if ((offset === zoneOffset) && (zoneName === "" || name === zoneName)) { + t.loc = local; + return [t, $ifaceNil]; + } + t.loc = FixedZone(zoneName, zoneOffset); + return [t, $ifaceNil]; + /* } */ case 6: + /* */ if (!(zoneName === "")) { $s = 9; continue; } + /* */ $s = 10; continue; + /* if (!(zoneName === "")) { */ case 9: + _r$4 = Date(year, (month >> 0), day, hour, min, sec, nsec, $pkg.UTC); /* */ $s = 11; case 11: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + t$1 = $clone(_r$4, Time); + _r$5 = local.lookupName(zoneName, (x$3 = t$1.sec, new $Int64(x$3.$high + -15, x$3.$low + 2288912640))); /* */ $s = 12; case 12: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + _tuple$24 = _r$5; + offset$1 = _tuple$24[0]; + ok$1 = _tuple$24[2]; + if (ok$1) { + t$1.sec = (x$4 = t$1.sec, x$5 = new $Int64(0, offset$1), new $Int64(x$4.$high - x$5.$high, x$4.$low - x$5.$low)); + t$1.loc = local; + return [t$1, $ifaceNil]; + } + if (zoneName.length > 3 && zoneName.substring(0, 3) === "GMT") { + _tuple$25 = atoi(zoneName.substring(3)); + offset$1 = _tuple$25[0]; + offset$1 = $imul(offset$1, (3600)); + } + t$1.loc = FixedZone(zoneName, offset$1); + return [t$1, $ifaceNil]; + /* } */ case 10: + _r$6 = Date(year, (month >> 0), day, hour, min, sec, nsec, defaultLocation); /* */ $s = 13; case 13: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + /* */ $s = 14; case 14: + return [_r$6, $ifaceNil]; + /* */ } return; } if ($f === undefined) { $f = { $blk: parse }; } $f.$ptr = $ptr; $f._3 = _3; $f._4 = _4; $f._5 = _5; $f._6 = _6; $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._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$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$25 = _tuple$25; $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 = 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.year = year; $f.z = z; $f.zoneName = zoneName; $f.zoneOffset = zoneOffset; $f.$s = $s; $f.$r = $r; return $f; + }; + parseTimeZone = function(value) { + var $ptr, _7, _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, c, length, nUpper, ok, 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 && (value.substring(0, 4) === "ChST" || value.substring(0, 4) === "MeST")) { + _tmp$2 = 4; + _tmp$3 = true; + length = _tmp$2; + ok = _tmp$3; + return [length, ok]; + } + if (value.substring(0, 3) === "GMT") { + length = parseGMT(value); + _tmp$4 = length; + _tmp$5 = true; + length = _tmp$4; + ok = _tmp$5; + 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; + } + _7 = nUpper; + if ((_7 === (0)) || (_7 === (1)) || (_7 === (2)) || (_7 === (6))) { + _tmp$6 = 0; + _tmp$7 = false; + length = _tmp$6; + ok = _tmp$7; + return [length, ok]; + } else if (_7 === (5)) { + if (value.charCodeAt(4) === 84) { + _tmp$8 = 5; + _tmp$9 = true; + length = _tmp$8; + ok = _tmp$9; + return [length, ok]; + } + } else if (_7 === (4)) { + if (value.charCodeAt(3) === 84) { + _tmp$10 = 4; + _tmp$11 = true; + length = _tmp$10; + ok = _tmp$11; + return [length, ok]; + } + } else if (_7 === (3)) { + _tmp$12 = 3; + _tmp$13 = true; + length = _tmp$12; + ok = _tmp$13; + return [length, ok]; + } + _tmp$14 = 0; + _tmp$15 = false; + length = _tmp$14; + ok = _tmp$15; + return [length, ok]; + }; + parseGMT = function(value) { + var $ptr, _tuple$1, err, rem, sign, value, x; + value = value.substring(3); + if (value.length === 0) { + return 3; + } + sign = value.charCodeAt(0); + if (!((sign === 45)) && !((sign === 43))) { + return 3; + } + _tuple$1 = leadingInt(value.substring(1)); + x = _tuple$1[0]; + rem = _tuple$1[1]; + err = _tuple$1[2]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + return 3; + } + if (sign === 45) { + x = new $Int64(-x.$high, -x.$low); + } + if ((x.$high === 0 && x.$low === 0) || (x.$high < -1 || (x.$high === -1 && x.$low < 4294967282)) || (0 < x.$high || (0 === x.$high && 12 < x.$low))) { + return 3; + } + return (3 + value.length >> 0) - rem.length >> 0; + }; + parseNanoseconds = function(value, nbytes) { + var $ptr, _tuple$1, err, i, nbytes, ns, rangeErrString, scaleDigits, value; + ns = 0; + rangeErrString = ""; + err = $ifaceNil; + if (!((value.charCodeAt(0) === 46))) { + err = errBad; + return [ns, rangeErrString, err]; + } + _tuple$1 = atoi(value.substring(1, nbytes)); + ns = _tuple$1[0]; + err = _tuple$1[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 $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, c, err, i, rem, s, x, x$1, x$2, x$3; + x = 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.$high > 214748364 || (x.$high === 214748364 && x.$low > 3435973836))) { + _tmp = new $Int64(0, 0); + _tmp$1 = ""; + _tmp$2 = errLeadingInt; + x = _tmp; + rem = _tmp$1; + err = _tmp$2; + return [x, rem, err]; + } + x = (x$1 = (x$2 = $mul64(x, new $Int64(0, 10)), x$3 = new $Int64(0, c), new $Int64(x$2.$high + x$3.$high, x$2.$low + x$3.$low)), new $Int64(x$1.$high - 0, x$1.$low - 48)); + if ((x.$high < 0 || (x.$high === 0 && x.$low < 0))) { + _tmp$3 = new $Int64(0, 0); + _tmp$4 = ""; + _tmp$5 = errLeadingInt; + x = _tmp$3; + rem = _tmp$4; + err = _tmp$5; + return [x, rem, err]; + } + i = i + (1) >> 0; + } + _tmp$6 = x; + _tmp$7 = s.substring(i); + _tmp$8 = $ifaceNil; + x = _tmp$6; + rem = _tmp$7; + err = _tmp$8; + return [x, rem, err]; + }; + ParseDuration = function(s) { + var $ptr, _entry, _tmp, _tmp$1, _tuple$1, _tuple$2, _tuple$3, c, c$1, d, err, f, i, n, neg, ok, orig, pl, pl$1, post, pre, s, scale, u, unit, v, x, x$1, x$2; + orig = s; + d = new $Int64(0, 0); + neg = false; + if (!(s === "")) { + c = s.charCodeAt(0); + if ((c === 45) || (c === 43)) { + neg = c === 45; + s = s.substring(1); + } + } + if (s === "0") { + return [new Duration(0, 0), $ifaceNil]; + } + if (s === "") { + return [new Duration(0, 0), errors.New("time: invalid duration " + orig)]; + } + while (true) { + if (!(!(s === ""))) { break; } + _tmp = new $Int64(0, 0); + _tmp$1 = new $Int64(0, 0); + v = _tmp; + f = _tmp$1; + scale = 1; + err = $ifaceNil; + if (!((s.charCodeAt(0) === 46) || 48 <= s.charCodeAt(0) && s.charCodeAt(0) <= 57)) { + return [new Duration(0, 0), errors.New("time: invalid duration " + orig)]; + } + pl = s.length; + _tuple$1 = leadingInt(s); + v = _tuple$1[0]; + s = _tuple$1[1]; + err = _tuple$1[2]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + return [new Duration(0, 0), errors.New("time: invalid duration " + orig)]; + } + pre = !((pl === s.length)); + post = false; + if (!(s === "") && (s.charCodeAt(0) === 46)) { + s = s.substring(1); + pl$1 = s.length; + _tuple$2 = leadingInt(s); + f = _tuple$2[0]; + s = _tuple$2[1]; + err = _tuple$2[2]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + return [new Duration(0, 0), errors.New("time: invalid duration " + orig)]; + } + n = pl$1 - s.length >> 0; + while (true) { + if (!(n > 0)) { break; } + scale = scale * (10); + n = n - (1) >> 0; + } + post = !((pl$1 === s.length)); + } + if (!pre && !post) { + return [new Duration(0, 0), errors.New("time: invalid duration " + orig)]; + } + i = 0; + while (true) { + if (!(i < s.length)) { break; } + c$1 = s.charCodeAt(i); + if ((c$1 === 46) || 48 <= c$1 && c$1 <= 57) { + break; + } + i = i + (1) >> 0; + } + if (i === 0) { + return [new Duration(0, 0), errors.New("time: missing unit in duration " + orig)]; + } + u = s.substring(0, i); + s = s.substring(i); + _tuple$3 = (_entry = unitMap[$String.keyFor(u)], _entry !== undefined ? [_entry.v, true] : [new $Int64(0, 0), false]); + unit = _tuple$3[0]; + ok = _tuple$3[1]; + if (!ok) { + return [new Duration(0, 0), errors.New("time: unknown unit " + u + " in duration " + orig)]; + } + if ((x = $div64(new $Int64(2147483647, 4294967295), unit, false), (v.$high > x.$high || (v.$high === x.$high && v.$low > x.$low)))) { + return [new Duration(0, 0), errors.New("time: invalid duration " + orig)]; + } + v = $mul64(v, (unit)); + if ((f.$high > 0 || (f.$high === 0 && f.$low > 0))) { + v = (x$1 = new $Int64(0, $flatten64(f) * ($flatten64(unit) / scale)), new $Int64(v.$high + x$1.$high, v.$low + x$1.$low)); + if ((v.$high < 0 || (v.$high === 0 && v.$low < 0))) { + return [new Duration(0, 0), errors.New("time: invalid duration " + orig)]; + } + } + d = (x$2 = v, new $Int64(d.$high + x$2.$high, d.$low + x$2.$low)); + if ((d.$high < 0 || (d.$high === 0 && d.$low < 0))) { + return [new Duration(0, 0), errors.New("time: invalid duration " + orig)]; + } + } + if (neg) { + d = new $Int64(-d.$high, -d.$low); + } + return [new Duration(d.$high, d.$low), $ifaceNil]; + }; + $pkg.ParseDuration = ParseDuration; + Time.ptr.prototype.After = function(u) { + var $ptr, t, u, x, x$1, x$2, x$3; + u = $clone(u, Time); + t = $clone(this, Time); + return (x = t.sec, x$1 = u.sec, (x.$high > x$1.$high || (x.$high === x$1.$high && x.$low > x$1.$low))) || (x$2 = t.sec, x$3 = u.sec, (x$2.$high === x$3.$high && x$2.$low === x$3.$low)) && t.nsec > u.nsec; + }; + Time.prototype.After = function(u) { return this.$val.After(u); }; + Time.ptr.prototype.Before = function(u) { + var $ptr, t, u, x, x$1, x$2, x$3; + u = $clone(u, Time); + t = $clone(this, Time); + return (x = t.sec, x$1 = u.sec, (x.$high < x$1.$high || (x.$high === x$1.$high && x.$low < x$1.$low))) || (x$2 = t.sec, x$3 = u.sec, (x$2.$high === x$3.$high && x$2.$low === x$3.$low)) && t.nsec < u.nsec; + }; + Time.prototype.Before = function(u) { return this.$val.Before(u); }; + Time.ptr.prototype.Equal = function(u) { + var $ptr, t, u, x, x$1; + u = $clone(u, Time); + t = $clone(this, Time); + return (x = t.sec, x$1 = u.sec, (x.$high === x$1.$high && x.$low === x$1.$low)) && (t.nsec === u.nsec); + }; + Time.prototype.Equal = function(u) { return this.$val.Equal(u); }; + Month.prototype.String = function() { + var $ptr, m, x; + m = this.$val; + return (x = m - 1 >> 0, ((x < 0 || x >= months.length) ? $throwRuntimeError("index out of range") : months[x])); + }; + $ptrType(Month).prototype.String = function() { return new Month(this.$get()).String(); }; + Weekday.prototype.String = function() { + var $ptr, d; + d = this.$val; + return ((d < 0 || d >= days.length) ? $throwRuntimeError("index out of range") : days[d]); + }; + $ptrType(Weekday).prototype.String = function() { return new Weekday(this.$get()).String(); }; + Time.ptr.prototype.IsZero = function() { + var $ptr, t, x; + t = $clone(this, Time); + return (x = t.sec, (x.$high === 0 && x.$low === 0)) && (t.nsec === 0); + }; + Time.prototype.IsZero = function() { return this.$val.IsZero(); }; + Time.ptr.prototype.abs = function() { + var $ptr, _r$1, _r$2, _tuple$1, l, offset, sec, t, 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; $ptr = $f.$ptr; _r$1 = $f._r$1; _r$2 = $f._r$2; _tuple$1 = $f._tuple$1; l = $f.l; offset = $f.offset; sec = $f.sec; t = $f.t; 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: + t = $clone(this, Time); + l = t.loc; + /* */ if (l === ptrType$1.nil || l === localLoc) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (l === ptrType$1.nil || l === localLoc) { */ case 1: + _r$1 = l.get(); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + l = _r$1; + /* } */ case 2: + sec = (x = t.sec, new $Int64(x.$high + -15, x.$low + 2288912640)); + /* */ 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$2 = l.lookup(sec); /* */ $s = 9; case 9: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _tuple$1 = _r$2; + offset = _tuple$1[1]; + sec = (x$4 = new $Int64(0, offset), new $Int64(sec.$high + x$4.$high, sec.$low + x$4.$low)); + /* } */ case 8: + /* } */ case 5: + 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.$ptr = $ptr; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tuple$1 = _tuple$1; $f.l = l; $f.offset = offset; $f.sec = sec; $f.t = t; $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; + }; + Time.prototype.abs = function() { return this.$val.abs(); }; + Time.ptr.prototype.locabs = function() { + var $ptr, _r$1, _r$2, _tuple$1, abs, l, name, offset, sec, t, 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; $ptr = $f.$ptr; _r$1 = $f._r$1; _r$2 = $f._r$2; _tuple$1 = $f._tuple$1; abs = $f.abs; l = $f.l; name = $f.name; offset = $f.offset; sec = $f.sec; t = $f.t; 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: + name = ""; + offset = 0; + abs = new $Uint64(0, 0); + t = $clone(this, Time); + l = t.loc; + /* */ if (l === ptrType$1.nil || l === localLoc) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (l === ptrType$1.nil || l === localLoc) { */ case 1: + _r$1 = l.get(); /* */ $s = 3; case 3: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + l = _r$1; + /* } */ case 2: + sec = (x = t.sec, new $Int64(x.$high + -15, x.$low + 2288912640)); + /* */ 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$2 = l.lookup(sec); /* */ $s = 10; case 10: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _tuple$1 = _r$2; + name = _tuple$1[0]; + offset = _tuple$1[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)); + return [name, offset, abs]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.locabs }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tuple$1 = _tuple$1; $f.abs = abs; $f.l = l; $f.name = name; $f.offset = offset; $f.sec = sec; $f.t = t; $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; + }; + Time.prototype.locabs = function() { return this.$val.locabs(); }; + Time.ptr.prototype.Date = function() { + var $ptr, _r$1, _tuple$1, day, month, t, year, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; _tuple$1 = $f._tuple$1; 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 = $clone(this, Time); + _r$1 = t.date(true); /* */ $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; + year = _tuple$1[0]; + month = _tuple$1[1]; + day = _tuple$1[2]; + return [year, month, day]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.Date }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f._tuple$1 = _tuple$1; $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 $ptr, _r$1, _tuple$1, t, year, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; _tuple$1 = $f._tuple$1; t = $f.t; year = $f.year; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = $clone(this, Time); + _r$1 = t.date(false); /* */ $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; + year = _tuple$1[0]; + return year; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.Year }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f._tuple$1 = _tuple$1; $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 $ptr, _r$1, _tuple$1, month, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; _tuple$1 = $f._tuple$1; month = $f.month; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = $clone(this, Time); + _r$1 = t.date(true); /* */ $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; + month = _tuple$1[1]; + return month; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.Month }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f._tuple$1 = _tuple$1; $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 $ptr, _r$1, _tuple$1, day, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; _tuple$1 = $f._tuple$1; day = $f.day; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = $clone(this, Time); + _r$1 = t.date(true); /* */ $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; + day = _tuple$1[2]; + return day; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.Day }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f._tuple$1 = _tuple$1; $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 $ptr, _r$1, _r$2, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; _r$2 = $f._r$2; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = $clone(this, Time); + _r$1 = t.abs(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$2 = absWeekday(_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 = 3; case 3: + return _r$2; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.Weekday }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.Weekday = function() { return this.$val.Weekday(); }; + absWeekday = function(abs) { + var $ptr, _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 $ptr, _q, _r$1, _r$2, _r$3, _r$4, _r$5, _tuple$1, 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; $ptr = $f.$ptr; _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; _tuple$1 = $f._tuple$1; 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 = $clone(this, Time); + _r$1 = t.date(true); /* */ $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; + year = _tuple$1[0]; + month = _tuple$1[1]; + day = _tuple$1[2]; + yday = _tuple$1[3]; + _r$3 = t.Weekday(); /* */ $s = 2; case 2: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + wday = (_r$2 = ((_r$3 + 6 >> 0) >> 0) % 7, _r$2 === _r$2 ? _r$2 : $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$4 = (((wday - yday >> 0) + 371 >> 0)) % 7, _r$4 === _r$4 ? _r$4 : $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$5 = (((wday + 31 >> 0) - day >> 0)) % 7, _r$5 === _r$5 ? _r$5 : $throwRuntimeError("integer divide by zero")); + if (0 <= dec31wday && dec31wday <= 2) { + year = year + (1) >> 0; + week = 1; + } + } + return [year, week]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.ISOWeek }; } $f.$ptr = $ptr; $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._tuple$1 = _tuple$1; $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 $ptr, _r$1, _r$2, _tuple$1, hour, min, sec, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; _r$2 = $f._r$2; _tuple$1 = $f._tuple$1; 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 = $clone(this, Time); + _r$1 = t.abs(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$2 = absClock(_r$1); /* */ $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; + hour = _tuple$1[0]; + min = _tuple$1[1]; + sec = _tuple$1[2]; + /* */ $s = 3; case 3: + return [hour, min, sec]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.Clock }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tuple$1 = _tuple$1; $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 $ptr, _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 $ptr, _q, _r$1, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _q = $f._q; _r$1 = $f._r$1; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = $clone(this, Time); + _r$1 = t.abs(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + /* */ $s = 2; case 2: + return (_q = ($div64(_r$1, 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.$ptr = $ptr; $f._q = _q; $f._r$1 = _r$1; $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 $ptr, _q, _r$1, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _q = $f._q; _r$1 = $f._r$1; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = $clone(this, Time); + _r$1 = t.abs(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + /* */ $s = 2; case 2: + return (_q = ($div64(_r$1, 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.$ptr = $ptr; $f._q = _q; $f._r$1 = _r$1; $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 $ptr, _r$1, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = $clone(this, Time); + _r$1 = t.abs(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + /* */ $s = 2; case 2: + return ($div64(_r$1, new $Uint64(0, 60), true).$low >> 0); + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.Second }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $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 $ptr, t; + t = $clone(this, Time); + return (t.nsec >> 0); + }; + Time.prototype.Nanosecond = function() { return this.$val.Nanosecond(); }; + Time.ptr.prototype.YearDay = function() { + var $ptr, _r$1, _tuple$1, t, yday, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; _tuple$1 = $f._tuple$1; t = $f.t; yday = $f.yday; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = $clone(this, Time); + _r$1 = t.date(false); /* */ $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; + yday = _tuple$1[3]; + return yday + 1 >> 0; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.YearDay }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f._tuple$1 = _tuple$1; $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 $ptr, _tuple$1, _tuple$2, buf, d, neg, prec, u, w; + d = this; + buf = arrayType$4.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") : buf[w] = 115); + w = w - (1) >> 0; + if ((u.$high === 0 && u.$low === 0)) { + return "0"; + } else if ((u.$high < 0 || (u.$high === 0 && u.$low < 1000))) { + prec = 0; + ((w < 0 || w >= buf.length) ? $throwRuntimeError("index out of range") : 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") : buf[w] = 109); + } + _tuple$1 = fmtFrac($subslice(new sliceType$3(buf), 0, w), u, prec); + w = _tuple$1[0]; + u = _tuple$1[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") : buf[w] = 115); + _tuple$2 = fmtFrac($subslice(new sliceType$3(buf), 0, w), u, 9); + w = _tuple$2[0]; + u = _tuple$2[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") : 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") : 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") : 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 $ptr, _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") : 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") : buf.$array[buf.$offset + w] = 46); + } + _tmp = w; + _tmp$1 = v; + nw = _tmp; + nv = _tmp$1; + return [nw, nv]; + }; + fmtInt = function(buf, v) { + var $ptr, 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") : 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") : 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 $ptr, d; + d = this; + return new $Int64(d.$high, d.$low); + }; + $ptrType(Duration).prototype.Nanoseconds = function() { return this.$get().Nanoseconds(); }; + Duration.prototype.Seconds = function() { + var $ptr, 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 $ptr, 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) * 1.6666666666666667e-11; + }; + $ptrType(Duration).prototype.Minutes = function() { return this.$get().Minutes(); }; + Duration.prototype.Hours = function() { + var $ptr, 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) * 2.777777777777778e-13; + }; + $ptrType(Duration).prototype.Hours = function() { return this.$get().Hours(); }; + Time.ptr.prototype.Add = function(d) { + var $ptr, d, nsec, t, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7; + t = $clone(this, Time); + t.sec = (x = t.sec, x$1 = (x$2 = $div64(d, new Duration(0, 1000000000), false), new $Int64(x$2.$high, x$2.$low)), new $Int64(x.$high + x$1.$high, x.$low + x$1.$low)); + nsec = t.nsec + ((x$3 = $div64(d, new Duration(0, 1000000000), true), x$3.$low + ((x$3.$high >> 31) * 4294967296)) >> 0) >> 0; + if (nsec >= 1000000000) { + t.sec = (x$4 = t.sec, x$5 = new $Int64(0, 1), new $Int64(x$4.$high + x$5.$high, x$4.$low + x$5.$low)); + nsec = nsec - (1000000000) >> 0; + } else if (nsec < 0) { + t.sec = (x$6 = t.sec, x$7 = new $Int64(0, 1), new $Int64(x$6.$high - x$7.$high, x$6.$low - x$7.$low)); + nsec = nsec + (1000000000) >> 0; + } + t.nsec = nsec; + return t; + }; + Time.prototype.Add = function(d) { return this.$val.Add(d); }; + Time.ptr.prototype.Sub = function(u) { + var $ptr, d, t, u, x, x$1, x$2, x$3, x$4; + u = $clone(u, Time); + t = $clone(this, Time); + d = (x = $mul64((x$1 = (x$2 = t.sec, x$3 = u.sec, new $Int64(x$2.$high - x$3.$high, x$2.$low - x$3.$low)), new Duration(x$1.$high, x$1.$low)), new Duration(0, 1000000000)), x$4 = new Duration(0, (t.nsec - u.nsec >> 0)), new Duration(x.$high + x$4.$high, x.$low + x$4.$low)); + if (u.Add(d).Equal(t)) { + return d; + } else if (t.Before(u)) { + return new Duration(-2147483648, 0); + } else { + return new Duration(2147483647, 4294967295); + } + }; + Time.prototype.Sub = function(u) { return this.$val.Sub(u); }; + Time.ptr.prototype.AddDate = function(years, months$1, days$1) { + var $ptr, _r$1, _r$2, _r$3, _tuple$1, _tuple$2, 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; $ptr = $f.$ptr; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; 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 = $clone(this, Time); + _r$1 = t.Date(); /* */ $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; + year = _tuple$1[0]; + month = _tuple$1[1]; + day = _tuple$1[2]; + _r$2 = t.Clock(); /* */ $s = 2; case 2: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _tuple$2 = _r$2; + hour = _tuple$2[0]; + min = _tuple$2[1]; + sec = _tuple$2[2]; + _r$3 = Date(year + years >> 0, month + (months$1 >> 0) >> 0, day + days$1 >> 0, hour, min, sec, (t.nsec >> 0), t.loc); /* */ $s = 3; case 3: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + /* */ $s = 4; case 4: + return _r$3; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.AddDate }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $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 $ptr, _r$1, _r$2, _tuple$1, day, full, month, t, yday, year, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; _r$2 = $f._r$2; _tuple$1 = $f._tuple$1; 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 = $clone(this, Time); + _r$1 = t.abs(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$2 = absDate(_r$1, full); /* */ $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; + year = _tuple$1[0]; + month = _tuple$1[1]; + day = _tuple$1[2]; + yday = _tuple$1[3]; + /* */ $s = 3; case 3: + return [year, month, day, yday]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.date }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tuple$1 = _tuple$1; $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 $ptr, _q, abs, begin, d, day, end, full, month, n, x, x$1, x$10, x$11, 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 = $mul64(new $Uint64(0, 146097), n), new $Uint64(d.$high - x.$high, d.$low - x.$low)); + n = $div64(d, new $Uint64(0, 36524), false); + n = (x$1 = $shiftRightUint64(n, 2), new $Uint64(n.$high - x$1.$high, n.$low - x$1.$low)); + y = (x$2 = $mul64(new $Uint64(0, 100), n), new $Uint64(y.$high + x$2.$high, y.$low + x$2.$low)); + d = (x$3 = $mul64(new $Uint64(0, 36524), n), new $Uint64(d.$high - x$3.$high, d.$low - x$3.$low)); + n = $div64(d, new $Uint64(0, 1461), false); + y = (x$4 = $mul64(new $Uint64(0, 4), n), new $Uint64(y.$high + x$4.$high, y.$low + x$4.$low)); + d = (x$5 = $mul64(new $Uint64(0, 1461), n), new $Uint64(d.$high - x$5.$high, d.$low - x$5.$low)); + n = $div64(d, new $Uint64(0, 365), false); + n = (x$6 = $shiftRightUint64(n, 2), new $Uint64(n.$high - x$6.$high, n.$low - x$6.$low)); + y = (x$7 = n, new $Uint64(y.$high + x$7.$high, y.$low + x$7.$low)); + d = (x$8 = $mul64(new $Uint64(0, 365), n), new $Uint64(d.$high - x$8.$high, d.$low - x$8.$low)); + year = ((x$9 = (x$10 = new $Int64(y.$high, y.$low), new $Int64(x$10.$high + -69, x$10.$low + 4075721025)), x$9.$low + ((x$9.$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$11 = month + 1 >> 0, ((x$11 < 0 || x$11 >= daysBefore.length) ? $throwRuntimeError("index out of range") : daysBefore[x$11])) >> 0); + begin = 0; + if (day >= end) { + month = month + (1) >> 0; + begin = end; + } else { + begin = (((month < 0 || month >= daysBefore.length) ? $throwRuntimeError("index out of range") : daysBefore[month]) >> 0); + } + month = month + (1) >> 0; + day = (day - begin >> 0) + 1 >> 0; + return [year, month, day, yday]; + }; + daysIn = function(m, year) { + var $ptr, m, x, year; + if ((m === 2) && isLeap(year)) { + return 29; + } + return ((((m < 0 || m >= daysBefore.length) ? $throwRuntimeError("index out of range") : daysBefore[m]) - (x = m - 1 >> 0, ((x < 0 || x >= daysBefore.length) ? $throwRuntimeError("index out of range") : daysBefore[x])) >> 0) >> 0); + }; + Time.ptr.prototype.UTC = function() { + var $ptr, t; + t = $clone(this, Time); + t.loc = $pkg.UTC; + return t; + }; + Time.prototype.UTC = function() { return this.$val.UTC(); }; + Time.ptr.prototype.Local = function() { + var $ptr, t; + t = $clone(this, Time); + t.loc = $pkg.Local; + return t; + }; + Time.prototype.Local = function() { return this.$val.Local(); }; + Time.ptr.prototype.In = function(loc) { + var $ptr, loc, t; + t = $clone(this, Time); + if (loc === ptrType$1.nil) { + $panic(new $String("time: missing Location in call to Time.In")); + } + t.loc = loc; + return t; + }; + Time.prototype.In = function(loc) { return this.$val.In(loc); }; + Time.ptr.prototype.Location = function() { + var $ptr, l, t; + t = $clone(this, Time); + l = t.loc; + if (l === ptrType$1.nil) { + l = $pkg.UTC; + } + return l; + }; + Time.prototype.Location = function() { return this.$val.Location(); }; + Time.ptr.prototype.Zone = function() { + var $ptr, _r$1, _tuple$1, name, offset, t, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; _tuple$1 = $f._tuple$1; name = $f.name; offset = $f.offset; t = $f.t; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + name = ""; + offset = 0; + t = $clone(this, Time); + _r$1 = t.loc.lookup((x = t.sec, new $Int64(x.$high + -15, x.$low + 2288912640))); /* */ $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; + name = _tuple$1[0]; + offset = _tuple$1[1]; + return [name, offset]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.Zone }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f._tuple$1 = _tuple$1; $f.name = name; $f.offset = offset; $f.t = t; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.Zone = function() { return this.$val.Zone(); }; + Time.ptr.prototype.Unix = function() { + var $ptr, t, x; + t = $clone(this, Time); + return (x = t.sec, new $Int64(x.$high + -15, x.$low + 2288912640)); + }; + Time.prototype.Unix = function() { return this.$val.Unix(); }; + Time.ptr.prototype.UnixNano = function() { + var $ptr, t, x, x$1, x$2; + t = $clone(this, Time); + return (x = $mul64(((x$1 = t.sec, new $Int64(x$1.$high + -15, x$1.$low + 2288912640))), new $Int64(0, 1000000000)), x$2 = new $Int64(0, t.nsec), new $Int64(x.$high + x$2.$high, x.$low + x$2.$low)); + }; + Time.prototype.UnixNano = function() { return this.$val.UnixNano(); }; + Time.ptr.prototype.MarshalBinary = function() { + var $ptr, _q, _r$1, _r$2, _tuple$1, enc, offset, offsetMin, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _q = $f._q; _r$1 = $f._r$1; _r$2 = $f._r$2; _tuple$1 = $f._tuple$1; enc = $f.enc; offset = $f.offset; offsetMin = $f.offsetMin; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = $clone(this, Time); + offsetMin = 0; + /* */ if (t.Location() === utcLoc) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (t.Location() === utcLoc) { */ case 1: + offsetMin = -1; + $s = 3; continue; + /* } else { */ case 2: + _r$1 = t.Zone(); /* */ $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; + offset = _tuple$1[1]; + if (!(((_r$2 = offset % 60, _r$2 === _r$2 ? _r$2 : $throwRuntimeError("integer divide by zero")) === 0))) { + 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) { + return [sliceType$3.nil, errors.New("Time.MarshalBinary: unexpected zone offset")]; + } + offsetMin = (offset << 16 >> 16); + /* } */ case 3: + enc = new sliceType$3([1, ($shiftRightInt64(t.sec, 56).$low << 24 >>> 24), ($shiftRightInt64(t.sec, 48).$low << 24 >>> 24), ($shiftRightInt64(t.sec, 40).$low << 24 >>> 24), ($shiftRightInt64(t.sec, 32).$low << 24 >>> 24), ($shiftRightInt64(t.sec, 24).$low << 24 >>> 24), ($shiftRightInt64(t.sec, 16).$low << 24 >>> 24), ($shiftRightInt64(t.sec, 8).$low << 24 >>> 24), (t.sec.$low << 24 >>> 24), ((t.nsec >> 24 >> 0) << 24 >>> 24), ((t.nsec >> 16 >> 0) << 24 >>> 24), ((t.nsec >> 8 >> 0) << 24 >>> 24), (t.nsec << 24 >>> 24), ((offsetMin >> 8 << 16 >> 16) << 24 >>> 24), (offsetMin << 24 >>> 24)]); + return [enc, $ifaceNil]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.MarshalBinary }; } $f.$ptr = $ptr; $f._q = _q; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._tuple$1 = _tuple$1; $f.enc = enc; $f.offset = offset; $f.offsetMin = offsetMin; $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$1) { + var $ptr, _r$1, _tuple$1, buf, data$1, localoff, offset, t, 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, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; _tuple$1 = $f._tuple$1; buf = $f.buf; data$1 = $f.data$1; localoff = $f.localoff; offset = $f.offset; t = $f.t; 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$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$1; + if (buf.$length === 0) { + return errors.New("Time.UnmarshalBinary: no data"); + } + if (!(((0 >= buf.$length ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + 0]) === 1))) { + return errors.New("Time.UnmarshalBinary: unsupported version"); + } + if (!((buf.$length === 15))) { + return errors.New("Time.UnmarshalBinary: invalid length"); + } + buf = $subslice(buf, 1); + t.sec = (x = (x$1 = (x$2 = (x$3 = (x$4 = (x$5 = (x$6 = new $Int64(0, (7 >= buf.$length ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + 7])), x$7 = $shiftLeft64(new $Int64(0, (6 >= buf.$length ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + 6])), 8), new $Int64(x$6.$high | x$7.$high, (x$6.$low | x$7.$low) >>> 0)), x$8 = $shiftLeft64(new $Int64(0, (5 >= buf.$length ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + 5])), 16), new $Int64(x$5.$high | x$8.$high, (x$5.$low | x$8.$low) >>> 0)), x$9 = $shiftLeft64(new $Int64(0, (4 >= buf.$length ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + 4])), 24), new $Int64(x$4.$high | x$9.$high, (x$4.$low | x$9.$low) >>> 0)), x$10 = $shiftLeft64(new $Int64(0, (3 >= buf.$length ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + 3])), 32), new $Int64(x$3.$high | x$10.$high, (x$3.$low | x$10.$low) >>> 0)), x$11 = $shiftLeft64(new $Int64(0, (2 >= buf.$length ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + 2])), 40), new $Int64(x$2.$high | x$11.$high, (x$2.$low | x$11.$low) >>> 0)), x$12 = $shiftLeft64(new $Int64(0, (1 >= buf.$length ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + 1])), 48), new $Int64(x$1.$high | x$12.$high, (x$1.$low | x$12.$low) >>> 0)), x$13 = $shiftLeft64(new $Int64(0, (0 >= buf.$length ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + 0])), 56), new $Int64(x.$high | x$13.$high, (x.$low | x$13.$low) >>> 0)); + buf = $subslice(buf, 8); + t.nsec = ((((3 >= buf.$length ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + 3]) >> 0) | (((2 >= buf.$length ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + 2]) >> 0) << 8 >> 0)) | (((1 >= buf.$length ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + 1]) >> 0) << 16 >> 0)) | (((0 >= buf.$length ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + 0]) >> 0) << 24 >> 0); + buf = $subslice(buf, 4); + offset = $imul(((((1 >= buf.$length ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + 1]) << 16 >> 16) | (((0 >= buf.$length ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + 0]) << 16 >> 16) << 8 << 16 >> 16)) >> 0), 60); + /* */ if (offset === -60) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (offset === -60) { */ case 1: + t.loc = utcLoc; + $s = 3; continue; + /* } else { */ case 2: + _r$1 = $pkg.Local.lookup((x$14 = t.sec, new $Int64(x$14.$high + -15, x$14.$low + 2288912640))); /* */ $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; + localoff = _tuple$1[1]; + if (offset === localoff) { + t.loc = $pkg.Local; + } else { + t.loc = FixedZone("", offset); + } + /* } */ case 3: + return $ifaceNil; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.UnmarshalBinary }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f._tuple$1 = _tuple$1; $f.buf = buf; $f.data$1 = data$1; $f.localoff = localoff; $f.offset = offset; $f.t = t; $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$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$1) { return this.$val.UnmarshalBinary(data$1); }; + Time.ptr.prototype.GobEncode = function() { + var $ptr, _r$1, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = $clone(this, Time); + _r$1 = t.MarshalBinary(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + /* */ $s = 2; case 2: + return _r$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.GobEncode }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $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$1) { + var $ptr, _r$1, data$1, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; data$1 = $f.data$1; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + _r$1 = t.UnmarshalBinary(data$1); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + /* */ $s = 2; case 2: + return _r$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.GobDecode }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f.data$1 = data$1; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.GobDecode = function(data$1) { return this.$val.GobDecode(data$1); }; + Time.ptr.prototype.MarshalJSON = function() { + var $ptr, _r$1, _r$2, b, t, y, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; _r$2 = $f._r$2; b = $f.b; t = $f.t; y = $f.y; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = $clone(this, Time); + _r$1 = t.Year(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + y = _r$1; + if (y < 0 || y >= 10000) { + 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$2 = t.AppendFormat(b, "2006-01-02T15:04:05.999999999Z07:00"); /* */ $s = 2; case 2: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + b = _r$2; + b = $append(b, 34); + return [b, $ifaceNil]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.MarshalJSON }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f._r$2 = _r$2; $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$1) { + var $ptr, _r$1, _tuple$1, data$1, err, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; _tuple$1 = $f._tuple$1; data$1 = $f.data$1; err = $f.err; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + err = $ifaceNil; + t = this; + _r$1 = Parse("\"2006-01-02T15:04:05Z07:00\"", $bytesToString(data$1)); /* */ $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; + Time.copy(t, _tuple$1[0]); + err = _tuple$1[1]; + return err; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.UnmarshalJSON }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f._tuple$1 = _tuple$1; $f.data$1 = data$1; $f.err = err; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.UnmarshalJSON = function(data$1) { return this.$val.UnmarshalJSON(data$1); }; + Time.ptr.prototype.MarshalText = function() { + var $ptr, _r$1, _r$2, b, t, y, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; _r$2 = $f._r$2; b = $f.b; t = $f.t; y = $f.y; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = $clone(this, Time); + _r$1 = t.Year(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + y = _r$1; + if (y < 0 || y >= 10000) { + return [sliceType$3.nil, errors.New("Time.MarshalText: year outside of range [0,9999]")]; + } + b = $makeSlice(sliceType$3, 0, 35); + _r$2 = t.AppendFormat(b, "2006-01-02T15:04:05.999999999Z07:00"); /* */ $s = 2; case 2: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + /* */ $s = 3; case 3: + return [_r$2, $ifaceNil]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.MarshalText }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f._r$2 = _r$2; $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$1) { + var $ptr, _r$1, _tuple$1, data$1, err, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; _tuple$1 = $f._tuple$1; data$1 = $f.data$1; err = $f.err; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + err = $ifaceNil; + t = this; + _r$1 = Parse("2006-01-02T15:04:05Z07:00", $bytesToString(data$1)); /* */ $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; + Time.copy(t, _tuple$1[0]); + err = _tuple$1[1]; + return err; + /* */ } return; } if ($f === undefined) { $f = { $blk: Time.ptr.prototype.UnmarshalText }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f._tuple$1 = _tuple$1; $f.data$1 = data$1; $f.err = err; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + Time.prototype.UnmarshalText = function(data$1) { return this.$val.UnmarshalText(data$1); }; + Unix = function(sec, nsec) { + var $ptr, n, nsec, sec, x, x$1, x$2, x$3; + 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 = n, new $Int64(sec.$high + x.$high, sec.$low + x.$low)); + nsec = (x$1 = $mul64(n, new $Int64(0, 1000000000)), new $Int64(nsec.$high - x$1.$high, nsec.$low - x$1.$low)); + if ((nsec.$high < 0 || (nsec.$high === 0 && nsec.$low < 0))) { + nsec = (x$2 = new $Int64(0, 1000000000), new $Int64(nsec.$high + x$2.$high, nsec.$low + x$2.$low)); + sec = (x$3 = new $Int64(0, 1), new $Int64(sec.$high - x$3.$high, sec.$low - x$3.$low)); + } + } + return new Time.ptr(new $Int64(sec.$high + 14, sec.$low + 2006054656), ((nsec.$low + ((nsec.$high >> 31) * 4294967296)) >> 0), $pkg.Local); + }; + $pkg.Unix = Unix; + isLeap = function(year) { + var $ptr, _r$1, _r$2, _r$3, year; + return ((_r$1 = year % 4, _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero")) === 0) && (!(((_r$2 = year % 100, _r$2 === _r$2 ? _r$2 : $throwRuntimeError("integer divide by zero")) === 0)) || ((_r$3 = year % 400, _r$3 === _r$3 ? _r$3 : $throwRuntimeError("integer divide by zero")) === 0)); + }; + norm = function(hi, lo, base) { + var $ptr, _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 $ptr, _r$1, _r$2, _r$3, _tuple$1, _tuple$2, _tuple$3, _tuple$4, _tuple$5, _tuple$6, _tuple$7, _tuple$8, abs, d, day, end, hour, loc, m, min, month, n, nsec, offset, sec, start, unix, utc, 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, y, year, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _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; 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; unix = $f.unix; utc = $f.utc; 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; y = $f.y; year = $f.year; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + if (loc === ptrType$1.nil) { + $panic(new $String("time: missing Location in call to Date")); + } + m = (month >> 0) - 1 >> 0; + _tuple$1 = norm(year, m, 12); + year = _tuple$1[0]; + m = _tuple$1[1]; + month = (m >> 0) + 1 >> 0; + _tuple$2 = norm(sec, nsec, 1000000000); + sec = _tuple$2[0]; + nsec = _tuple$2[1]; + _tuple$3 = norm(min, sec, 60); + min = _tuple$3[0]; + sec = _tuple$3[1]; + _tuple$4 = norm(hour, min, 60); + hour = _tuple$4[0]; + min = _tuple$4[1]; + _tuple$5 = norm(day, hour, 24); + day = _tuple$5[0]; + hour = _tuple$5[1]; + y = (x = (x$1 = new $Int64(0, year), new $Int64(x$1.$high - -69, x$1.$low - 4075721025)), new $Uint64(x.$high, x.$low)); + n = $div64(y, new $Uint64(0, 400), false); + y = (x$2 = $mul64(new $Uint64(0, 400), n), new $Uint64(y.$high - x$2.$high, y.$low - x$2.$low)); + d = $mul64(new $Uint64(0, 146097), n); + n = $div64(y, new $Uint64(0, 100), false); + 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(y, new $Uint64(0, 4), 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 = y; + d = (x$7 = $mul64(new $Uint64(0, 365), n), new $Uint64(d.$high + x$7.$high, d.$low + x$7.$low)); + d = (x$8 = new $Uint64(0, (x$9 = month - 1 >> 0, ((x$9 < 0 || x$9 >= daysBefore.length) ? $throwRuntimeError("index out of range") : daysBefore[x$9]))), new $Uint64(d.$high + x$8.$high, d.$low + x$8.$low)); + if (isLeap(year) && month >= 3) { + d = (x$10 = new $Uint64(0, 1), new $Uint64(d.$high + x$10.$high, d.$low + x$10.$low)); + } + d = (x$11 = new $Uint64(0, (day - 1 >> 0)), new $Uint64(d.$high + x$11.$high, d.$low + x$11.$low)); + abs = $mul64(d, new $Uint64(0, 86400)); + abs = (x$12 = new $Uint64(0, ((($imul(hour, 3600)) + ($imul(min, 60)) >> 0) + sec >> 0)), new $Uint64(abs.$high + x$12.$high, abs.$low + x$12.$low)); + unix = (x$13 = new $Int64(abs.$high, abs.$low), new $Int64(x$13.$high + -2147483647, x$13.$low + 3844486912)); + _r$1 = loc.lookup(unix); /* */ $s = 1; case 1: 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]; + start = _tuple$6[3]; + end = _tuple$6[4]; + /* */ if (!((offset === 0))) { $s = 2; continue; } + /* */ $s = 3; continue; + /* if (!((offset === 0))) { */ case 2: + utc = (x$14 = new $Int64(0, offset), new $Int64(unix.$high - x$14.$high, unix.$low - x$14.$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$2 = loc.lookup(new $Int64(start.$high - 0, start.$low - 1)); /* */ $s = 8; case 8: 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]; + $s = 7; continue; + /* } else if ((utc.$high > end.$high || (utc.$high === end.$high && utc.$low >= end.$low))) { */ case 6: + _r$3 = loc.lookup(end); /* */ $s = 9; case 9: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _tuple$8 = _r$3; + offset = _tuple$8[1]; + /* } */ case 7: + case 4: + unix = (x$15 = new $Int64(0, offset), new $Int64(unix.$high - x$15.$high, unix.$low - x$15.$low)); + /* } */ case 3: + return new Time.ptr(new $Int64(unix.$high + 14, unix.$low + 2006054656), (nsec >> 0), loc); + /* */ } return; } if ($f === undefined) { $f = { $blk: Date }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $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.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.unix = unix; $f.utc = utc; $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.y = y; $f.year = year; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.Date = Date; + Time.ptr.prototype.Truncate = function(d) { + var $ptr, _tuple$1, d, r, t; + t = $clone(this, Time); + if ((d.$high < 0 || (d.$high === 0 && d.$low <= 0))) { + return t; + } + _tuple$1 = div(t, d); + r = _tuple$1[1]; + return t.Add(new Duration(-r.$high, -r.$low)); + }; + Time.prototype.Truncate = function(d) { return this.$val.Truncate(d); }; + Time.ptr.prototype.Round = function(d) { + var $ptr, _tuple$1, d, r, t, x; + t = $clone(this, Time); + if ((d.$high < 0 || (d.$high === 0 && d.$low <= 0))) { + return t; + } + _tuple$1 = div(t, d); + r = _tuple$1[1]; + if ((x = new Duration(r.$high + r.$high, r.$low + r.$low), (x.$high < d.$high || (x.$high === d.$high && x.$low < d.$low)))) { + return t.Add(new Duration(-r.$high, -r.$low)); + } + return t.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 $ptr, _q, _r$1, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, d, d0, d1, d1$1, neg, nsec, qmod2, r, sec, t, tmp, u0, u0x, u1, 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$3, x$4, x$5, x$6, x$7, x$8, x$9; + qmod2 = 0; + r = new Duration(0, 0); + t = $clone(t, Time); + neg = false; + nsec = t.nsec; + if ((x = t.sec, (x.$high < 0 || (x.$high === 0 && x.$low < 0)))) { + neg = true; + t.sec = (x$1 = t.sec, new $Int64(-x$1.$high, -x$1.$low)); + nsec = -nsec; + if (nsec < 0) { + nsec = nsec + (1000000000) >> 0; + t.sec = (x$2 = t.sec, x$3 = new $Int64(0, 1), new $Int64(x$2.$high - x$3.$high, x$2.$low - x$3.$low)); + } + } + if ((d.$high < 0 || (d.$high === 0 && d.$low < 1000000000)) && (x$4 = $div64(new Duration(0, 1000000000), (new Duration(d.$high + d.$high, d.$low + d.$low)), true), (x$4.$high === 0 && x$4.$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$1 = nsec % ((d.$low + ((d.$high >> 31) * 4294967296)) >> 0), _r$1 === _r$1 ? _r$1 : $throwRuntimeError("integer divide by zero"))); + } else if ((x$5 = $div64(d, new Duration(0, 1000000000), true), (x$5.$high === 0 && x$5.$low === 0))) { + d1 = (x$6 = $div64(d, new Duration(0, 1000000000), false), new $Int64(x$6.$high, x$6.$low)); + qmod2 = ((x$7 = $div64(t.sec, d1, false), x$7.$low + ((x$7.$high >> 31) * 4294967296)) >> 0) & 1; + r = (x$8 = $mul64((x$9 = $div64(t.sec, d1, true), new Duration(x$9.$high, x$9.$low)), new Duration(0, 1000000000)), x$10 = new Duration(0, nsec), new Duration(x$8.$high + x$10.$high, x$8.$low + x$10.$low)); + } else { + sec = (x$11 = t.sec, new $Uint64(x$11.$high, x$11.$low)); + tmp = $mul64(($shiftRightUint64(sec, 32)), new $Uint64(0, 1000000000)); + u1 = $shiftRightUint64(tmp, 32); + u0 = $shiftLeft64(tmp, 32); + tmp = $mul64(new $Uint64(sec.$high & 0, (sec.$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$12 = new $Uint64(0, 1), new $Uint64(u1.$high + x$12.$high, u1.$low + x$12.$low)); + } + _tmp$2 = u0; + _tmp$3 = (x$13 = new $Uint64(0, nsec), new $Uint64(u0.$high + x$13.$high, u0.$low + x$13.$low)); + u0x = _tmp$2; + u0 = _tmp$3; + if ((u0.$high < u0x.$high || (u0.$high === u0x.$high && u0.$low < u0x.$low))) { + u1 = (x$14 = new $Uint64(0, 1), new $Uint64(u1.$high + x$14.$high, u1.$low + x$14.$low)); + } + d1$1 = new $Uint64(d.$high, d.$low); + while (true) { + if (!(!((x$15 = $shiftRightUint64(d1$1, 63), (x$15.$high === 0 && x$15.$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$16 = new $Uint64(0, 1), new $Uint64(u1.$high - x$16.$high, u1.$low - x$16.$low)); + } + u1 = (x$17 = d1$1, new $Uint64(u1.$high - x$17.$high, u1.$low - x$17.$low)); + } + if ((d1$1.$high === 0 && d1$1.$low === 0) && (x$18 = new $Uint64(d.$high, d.$low), (d0.$high === x$18.$high && d0.$low === x$18.$low))) { + break; + } + d0 = $shiftRightUint64(d0, (1)); + d0 = (x$19 = $shiftLeft64((new $Uint64(d1$1.$high & 0, (d1$1.$low & 1) >>> 0)), 63), new $Uint64(d0.$high | x$19.$high, (d0.$low | x$19.$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 $ptr, l, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; l = $f.l; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + l = this; + if (l === ptrType$1.nil) { + 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: + return l; + /* */ } return; } if ($f === undefined) { $f = { $blk: Location.ptr.prototype.get }; } $f.$ptr = $ptr; $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 $ptr, _r$1, l, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$1 = $f._r$1; l = $f.l; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + l = this; + _r$1 = l.get(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + /* */ $s = 2; case 2: + return _r$1.name; + /* */ } return; } if ($f === undefined) { $f = { $blk: Location.ptr.prototype.String }; } $f.$ptr = $ptr; $f._r$1 = _r$1; $f.l = l; $f.$s = $s; $f.$r = $r; return $f; + }; + Location.prototype.String = function() { return this.$val.String(); }; + FixedZone = function(name, offset) { + var $ptr, l, name, offset, x; + 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 = l.zone, (0 >= x.$length ? $throwRuntimeError("index out of range") : x.$array[x.$offset + 0])); + return l; + }; + $pkg.FixedZone = FixedZone; + Location.ptr.prototype.lookup = function(sec) { + var $ptr, _q, _r$1, end, hi, isDST, l, lim, lo, m, name, offset, sec, start, tx, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7, x$8, zone$1, zone$2, zone$3, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _q = $f._q; _r$1 = $f._r$1; end = $f.end; hi = $f.hi; isDST = $f.isDST; 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 = $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; 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; + isDST = false; + start = new $Int64(0, 0); + end = new $Int64(0, 0); + l = this; + _r$1 = l.get(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + l = _r$1; + if (l.zone.$length === 0) { + name = "UTC"; + offset = 0; + isDST = false; + start = new $Int64(-2147483648, 0); + end = new $Int64(2147483647, 4294967295); + return [name, offset, isDST, start, end]; + } + zone$1 = l.cacheZone; + if (!(zone$1 === ptrType.nil) && (x = l.cacheStart, (x.$high < sec.$high || (x.$high === sec.$high && x.$low <= sec.$low))) && (x$1 = l.cacheEnd, (sec.$high < x$1.$high || (sec.$high === x$1.$high && sec.$low < x$1.$low)))) { + name = zone$1.name; + offset = zone$1.offset; + isDST = zone$1.isDST; + start = l.cacheStart; + end = l.cacheEnd; + return [name, offset, isDST, start, end]; + } + if ((l.tx.$length === 0) || (x$2 = (x$3 = l.tx, (0 >= x$3.$length ? $throwRuntimeError("index out of range") : x$3.$array[x$3.$offset + 0])).when, (sec.$high < x$2.$high || (sec.$high === x$2.$high && sec.$low < x$2.$low)))) { + zone$2 = (x$4 = l.zone, x$5 = l.lookupFirstZone(), ((x$5 < 0 || x$5 >= x$4.$length) ? $throwRuntimeError("index out of range") : x$4.$array[x$4.$offset + x$5])); + name = zone$2.name; + offset = zone$2.offset; + isDST = zone$2.isDST; + start = new $Int64(-2147483648, 0); + if (l.tx.$length > 0) { + end = (x$6 = l.tx, (0 >= x$6.$length ? $throwRuntimeError("index out of range") : x$6.$array[x$6.$offset + 0])).when; + } else { + end = new $Int64(2147483647, 4294967295); + } + return [name, offset, isDST, 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") : 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$7 = l.zone, x$8 = ((lo < 0 || lo >= tx.$length) ? $throwRuntimeError("index out of range") : tx.$array[tx.$offset + lo]).index, ((x$8 < 0 || x$8 >= x$7.$length) ? $throwRuntimeError("index out of range") : x$7.$array[x$7.$offset + x$8])); + name = zone$3.name; + offset = zone$3.offset; + isDST = zone$3.isDST; + start = ((lo < 0 || lo >= tx.$length) ? $throwRuntimeError("index out of range") : tx.$array[tx.$offset + lo]).when; + return [name, offset, isDST, start, end]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Location.ptr.prototype.lookup }; } $f.$ptr = $ptr; $f._q = _q; $f._r$1 = _r$1; $f.end = end; $f.hi = hi; $f.isDST = isDST; $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 = 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.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 $ptr, _i, _ref, l, x, x$1, x$2, x$3, x$4, x$5, zi, zi$1; + l = this; + if (!l.firstZoneUsed()) { + return 0; + } + if (l.tx.$length > 0 && (x = l.zone, x$1 = (x$2 = l.tx, (0 >= x$2.$length ? $throwRuntimeError("index out of range") : x$2.$array[x$2.$offset + 0])).index, ((x$1 < 0 || x$1 >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + x$1])).isDST) { + zi = ((x$3 = l.tx, (0 >= x$3.$length ? $throwRuntimeError("index out of range") : x$3.$array[x$3.$offset + 0])).index >> 0) - 1 >> 0; + while (true) { + if (!(zi >= 0)) { break; } + if (!(x$4 = l.zone, ((zi < 0 || zi >= x$4.$length) ? $throwRuntimeError("index out of range") : x$4.$array[x$4.$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$5 = l.zone, ((zi$1 < 0 || zi$1 >= x$5.$length) ? $throwRuntimeError("index out of range") : x$5.$array[x$5.$offset + zi$1])).isDST) { + return zi$1; + } + _i++; + } + return 0; + }; + Location.prototype.lookupFirstZone = function() { return this.$val.lookupFirstZone(); }; + Location.ptr.prototype.firstZoneUsed = function() { + var $ptr, _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") : _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 $ptr, _i, _i$1, _r$1, _r$2, _ref, _ref$1, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tuple$1, i, i$1, isDST, isDST$1, l, nam, name, offset, offset$1, ok, unix, x, x$1, x$2, zone$1, zone$2, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _i$1 = $f._i$1; _r$1 = $f._r$1; _r$2 = $f._r$2; _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$1 = $f._tuple$1; i = $f.i; i$1 = $f.i$1; isDST = $f.isDST; isDST$1 = $f.isDST$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 = $f.x; x$1 = $f.x$1; x$2 = $f.x$2; 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; + isDST = false; + ok = false; + l = this; + _r$1 = l.get(); /* */ $s = 1; case 1: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + l = _r$1; + _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 = l.zone, ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i])); + /* */ if (zone$1.name === name) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (zone$1.name === name) { */ case 4: + _r$2 = l.lookup((x$1 = new $Int64(0, zone$1.offset), new $Int64(unix.$high - x$1.$high, unix.$low - x$1.$low))); /* */ $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; + nam = _tuple$1[0]; + offset$1 = _tuple$1[1]; + isDST$1 = _tuple$1[2]; + if (nam === zone$1.name) { + _tmp = offset$1; + _tmp$1 = isDST$1; + _tmp$2 = true; + offset = _tmp; + isDST = _tmp$1; + ok = _tmp$2; + return [offset, isDST, 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$2 = l.zone, ((i$1 < 0 || i$1 >= x$2.$length) ? $throwRuntimeError("index out of range") : x$2.$array[x$2.$offset + i$1])); + if (zone$2.name === name) { + _tmp$3 = zone$2.offset; + _tmp$4 = zone$2.isDST; + _tmp$5 = true; + offset = _tmp$3; + isDST = _tmp$4; + ok = _tmp$5; + return [offset, isDST, ok]; + } + _i$1++; + } + return [offset, isDST, ok]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Location.ptr.prototype.lookupName }; } $f.$ptr = $ptr; $f._i = _i; $f._i$1 = _i$1; $f._r$1 = _r$1; $f._r$2 = _r$2; $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$1 = _tuple$1; $f.i = i; $f.i$1 = i$1; $f.isDST = isDST; $f.isDST$1 = isDST$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 = x; $f.x$1 = x$1; $f.x$2 = x$2; $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$3.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$1], [Time], false)}, {prop: "Location", name: "Location", pkg: "", typ: $funcType([], [ptrType$1], 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$6.methods = [{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)}]; + ptrType$1.methods = [{prop: "get", name: "get", pkg: "time", typ: $funcType([], [ptrType$1], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "lookup", name: "lookup", pkg: "time", typ: $funcType([$Int64], [$String, $Int, $Bool, $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, $Bool], false)}]; + ParseError.init([{prop: "Layout", name: "Layout", pkg: "", typ: $String, tag: ""}, {prop: "Value", name: "Value", pkg: "", typ: $String, tag: ""}, {prop: "LayoutElem", name: "LayoutElem", pkg: "", typ: $String, tag: ""}, {prop: "ValueElem", name: "ValueElem", pkg: "", typ: $String, tag: ""}, {prop: "Message", name: "Message", pkg: "", typ: $String, tag: ""}]); + Time.init([{prop: "sec", name: "sec", pkg: "time", typ: $Int64, tag: ""}, {prop: "nsec", name: "nsec", pkg: "time", typ: $Int32, tag: ""}, {prop: "loc", name: "loc", pkg: "time", typ: ptrType$1, tag: ""}]); + Location.init([{prop: "name", name: "name", pkg: "time", typ: $String, tag: ""}, {prop: "zone", name: "zone", pkg: "time", typ: sliceType, tag: ""}, {prop: "tx", name: "tx", pkg: "time", typ: sliceType$1, tag: ""}, {prop: "cacheStart", name: "cacheStart", pkg: "time", typ: $Int64, tag: ""}, {prop: "cacheEnd", name: "cacheEnd", pkg: "time", typ: $Int64, tag: ""}, {prop: "cacheZone", name: "cacheZone", pkg: "time", typ: ptrType, tag: ""}]); + zone.init([{prop: "name", name: "name", pkg: "time", typ: $String, tag: ""}, {prop: "offset", name: "offset", pkg: "time", typ: $Int, tag: ""}, {prop: "isDST", name: "isDST", pkg: "time", typ: $Bool, tag: ""}]); + zoneTrans.init([{prop: "when", name: "when", pkg: "time", typ: $Int64, tag: ""}, {prop: "index", name: "index", pkg: "time", typ: $Uint8, tag: ""}, {prop: "isstd", name: "isstd", pkg: "time", typ: $Bool, tag: ""}, {prop: "isutc", name: "isutc", pkg: "time", 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 = strings.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = syscall.$init(); /* */ $s = 6; case 6: 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); + 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"]); + unitMap = $makeMap($String.keyFor, [{ k: "ns", v: new $Int64(0, 1) }, { k: "us", v: new $Int64(0, 1000) }, { k: "\xC2\xB5s", v: new $Int64(0, 1000) }, { k: "\xCE\xBCs", v: new $Int64(0, 1000) }, { k: "ms", v: new $Int64(0, 1000000) }, { k: "s", v: new $Int64(0, 1000000000) }, { k: "m", v: new $Int64(13, 4165425152) }, { k: "h", v: new $Int64(838, 817405952) }]); + daysBefore = $toNativeArray($kindInt32, [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365]); + 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; + _r = syscall.Getenv("ZONEINFO"); /* */ $s = 7; case 7: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + zoneinfo = _tuple[0]; + badData = errors.New("malformed time zone information"); + zoneDirs = 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["os"] = (function() { + var $pkg = {}, $init, errors, js, io, runtime, sync, atomic, syscall, time, PathError, SyscallError, LinkError, File, file, dirInfo, FileInfo, FileMode, fileStat, sliceType, ptrType, sliceType$1, sliceType$2, ptrType$1, ptrType$2, ptrType$3, ptrType$4, ptrType$12, funcType$1, ptrType$13, arrayType$1, arrayType$5, ptrType$15, errFinished, lstat, runtime_args, init, runtime_beforeExit, NewSyscallError, IsNotExist, isNotExist, fixCount, sigpipe, syscallMode, NewFile, epipecheck, Lstat, basename, init$1, Exit, fillFileStatFromSys, timespecToTime; + errors = $packages["errors"]; + js = $packages["github.com/gopherjs/gopherjs/js"]; + io = $packages["io"]; + runtime = $packages["runtime"]; + sync = $packages["sync"]; + atomic = $packages["sync/atomic"]; + syscall = $packages["syscall"]; + time = $packages["time"]; + PathError = $pkg.PathError = $newType(0, $kindStruct, "os.PathError", "PathError", "os", 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", "SyscallError", "os", 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", "LinkError", "os", 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", "File", "os", function(file_) { + this.$val = this; + if (arguments.length === 0) { + this.file = ptrType$12.nil; + return; + } + this.file = file_; + }); + file = $pkg.file = $newType(0, $kindStruct, "os.file", "file", "os", function(fd_, name_, dirinfo_) { + this.$val = this; + if (arguments.length === 0) { + this.fd = 0; + this.name = ""; + this.dirinfo = ptrType.nil; + return; + } + this.fd = fd_; + this.name = name_; + this.dirinfo = dirinfo_; + }); + dirInfo = $pkg.dirInfo = $newType(0, $kindStruct, "os.dirInfo", "dirInfo", "os", function(buf_, nbuf_, bufp_) { + this.$val = this; + if (arguments.length === 0) { + this.buf = sliceType$1.nil; + this.nbuf = 0; + this.bufp = 0; + return; + } + this.buf = buf_; + this.nbuf = nbuf_; + this.bufp = bufp_; + }); + FileInfo = $pkg.FileInfo = $newType(8, $kindInterface, "os.FileInfo", "FileInfo", "os", null); + FileMode = $pkg.FileMode = $newType(4, $kindUint32, "os.FileMode", "FileMode", "os", null); + fileStat = $pkg.fileStat = $newType(0, $kindStruct, "os.fileStat", "fileStat", "os", 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 $Int64(0, 0), 0, ptrType$13.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(dirInfo); + sliceType$1 = $sliceType($Uint8); + sliceType$2 = $sliceType(FileInfo); + ptrType$1 = $ptrType(File); + ptrType$2 = $ptrType(PathError); + ptrType$3 = $ptrType(LinkError); + ptrType$4 = $ptrType(SyscallError); + ptrType$12 = $ptrType(file); + funcType$1 = $funcType([ptrType$12], [$error], false); + ptrType$13 = $ptrType(time.Location); + arrayType$1 = $arrayType($Int64, 3); + arrayType$5 = $arrayType($Uint8, 32); + ptrType$15 = $ptrType(fileStat); + runtime_args = function() { + var $ptr; + return $pkg.Args; + }; + init = function() { + var $ptr, 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") : $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() { + var $ptr; + }; + File.ptr.prototype.readdirnames = function(n) { + var $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tuple, _tuple$1, _tuple$2, d, err, errno, f, n, names, nb, nc, size; + names = sliceType.nil; + err = $ifaceNil; + f = this; + if (f.file.dirinfo === ptrType.nil) { + f.file.dirinfo = new dirInfo.ptr(sliceType$1.nil, 0, 0); + f.file.dirinfo.buf = $makeSlice(sliceType$1, 4096); + } + d = f.file.dirinfo; + size = n; + if (size <= 0) { + size = 100; + n = -1; + } + names = $makeSlice(sliceType, 0, size); + while (true) { + if (!(!((n === 0)))) { break; } + if (d.bufp >= d.nbuf) { + d.bufp = 0; + errno = $ifaceNil; + _tuple$1 = syscall.ReadDirent(f.file.fd, d.buf); + _tuple = fixCount(_tuple$1[0], _tuple$1[1]); + d.nbuf = _tuple[0]; + errno = _tuple[1]; + if (!($interfaceIsEqual(errno, $ifaceNil))) { + _tmp = names; + _tmp$1 = NewSyscallError("readdirent", errno); + names = _tmp; + err = _tmp$1; + return [names, err]; + } + if (d.nbuf <= 0) { + break; + } + } + _tmp$2 = 0; + _tmp$3 = 0; + nb = _tmp$2; + nc = _tmp$3; + _tuple$2 = syscall.ParseDirent($subslice(d.buf, d.bufp, d.nbuf), n, names); + nb = _tuple$2[0]; + nc = _tuple$2[1]; + names = _tuple$2[2]; + d.bufp = d.bufp + (nb) >> 0; + n = n - (nc) >> 0; + } + if (n >= 0 && (names.$length === 0)) { + _tmp$4 = names; + _tmp$5 = io.EOF; + names = _tmp$4; + err = _tmp$5; + return [names, err]; + } + _tmp$6 = names; + _tmp$7 = $ifaceNil; + names = _tmp$6; + err = _tmp$7; + return [names, err]; + }; + File.prototype.readdirnames = function(n) { return this.$val.readdirnames(n); }; + File.ptr.prototype.Readdir = function(n) { + var $ptr, _r, _tmp, _tmp$1, _tuple, err, f, fi, n, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; err = $f.err; f = $f.f; fi = $f.fi; n = $f.n; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + fi = sliceType$2.nil; + err = $ifaceNil; + f = this; + if (f === ptrType$1.nil) { + _tmp = sliceType$2.nil; + _tmp$1 = $pkg.ErrInvalid; + fi = _tmp; + err = _tmp$1; + return [fi, err]; + } + _r = f.readdir(n); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + fi = _tuple[0]; + err = _tuple[1]; + /* */ $s = 2; case 2: + return [fi, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.Readdir }; } $f.$ptr = $ptr; $f._r = _r; $f._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f.err = err; $f.f = f; $f.fi = fi; $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 $ptr, _tmp, _tmp$1, _tuple, err, f, n, names; + names = sliceType.nil; + err = $ifaceNil; + f = this; + if (f === ptrType$1.nil) { + _tmp = sliceType.nil; + _tmp$1 = $pkg.ErrInvalid; + names = _tmp; + err = _tmp$1; + return [names, err]; + } + _tuple = f.readdirnames(n); + names = _tuple[0]; + err = _tuple[1]; + return [names, err]; + }; + File.prototype.Readdirnames = function(n) { return this.$val.Readdirnames(n); }; + PathError.ptr.prototype.Error = function() { + var $ptr, _r, e, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _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 = 2; case 2: + return e.Op + " " + e.Path + ": " + _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: PathError.ptr.prototype.Error }; } $f.$ptr = $ptr; $f._r = _r; $f.e = e; $f.$s = $s; $f.$r = $r; return $f; + }; + PathError.prototype.Error = function() { return this.$val.Error(); }; + SyscallError.ptr.prototype.Error = function() { + var $ptr, _r, e, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _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 = 2; case 2: + return e.Syscall + ": " + _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: SyscallError.ptr.prototype.Error }; } $f.$ptr = $ptr; $f._r = _r; $f.e = e; $f.$s = $s; $f.$r = $r; return $f; + }; + SyscallError.prototype.Error = function() { return this.$val.Error(); }; + NewSyscallError = function(syscall$1, err) { + var $ptr, err, syscall$1; + if ($interfaceIsEqual(err, $ifaceNil)) { + return $ifaceNil; + } + return new SyscallError.ptr(syscall$1, err); + }; + $pkg.NewSyscallError = NewSyscallError; + IsNotExist = function(err) { + var $ptr, err; + return isNotExist(err); + }; + $pkg.IsNotExist = IsNotExist; + isNotExist = function(err) { + var $ptr, _ref, err, pe, pe$1, pe$2, pe$3; + _ref = err; + if (_ref === $ifaceNil) { + pe = _ref; + return false; + } else if ($assertType(_ref, ptrType$2, true)[1]) { + pe$1 = _ref.$val; + err = pe$1.Err; + } else if ($assertType(_ref, ptrType$3, true)[1]) { + pe$2 = _ref.$val; + err = pe$2.Err; + } else if ($assertType(_ref, ptrType$4, true)[1]) { + pe$3 = _ref.$val; + err = pe$3.Err; + } + return $interfaceIsEqual(err, new syscall.Errno(2)) || $interfaceIsEqual(err, $pkg.ErrNotExist); + }; + File.ptr.prototype.Name = function() { + var $ptr, f; + f = this; + return f.file.name; + }; + File.prototype.Name = function() { return this.$val.Name(); }; + LinkError.ptr.prototype.Error = function() { + var $ptr, _r, e, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _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 = 2; case 2: + return e.Op + " " + e.Old + " " + e.New + ": " + _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: LinkError.ptr.prototype.Error }; } $f.$ptr = $ptr; $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 $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tuple, b, e, err, f, n; + n = 0; + err = $ifaceNil; + f = this; + if (f === ptrType$1.nil) { + _tmp = 0; + _tmp$1 = $pkg.ErrInvalid; + n = _tmp; + err = _tmp$1; + return [n, err]; + } + _tuple = f.read(b); + n = _tuple[0]; + e = _tuple[1]; + if ((n === 0) && b.$length > 0 && $interfaceIsEqual(e, $ifaceNil)) { + _tmp$2 = 0; + _tmp$3 = io.EOF; + n = _tmp$2; + err = _tmp$3; + return [n, err]; + } + if (!($interfaceIsEqual(e, $ifaceNil))) { + err = new PathError.ptr("read", f.file.name, e); + } + _tmp$4 = n; + _tmp$5 = err; + n = _tmp$4; + err = _tmp$5; + return [n, err]; + }; + File.prototype.Read = function(b) { return this.$val.Read(b); }; + File.ptr.prototype.ReadAt = function(b, off) { + var $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, b, e, err, f, m, n, off, x; + n = 0; + err = $ifaceNil; + f = this; + if (f === ptrType$1.nil) { + _tmp = 0; + _tmp$1 = $pkg.ErrInvalid; + n = _tmp; + err = _tmp$1; + return [n, err]; + } + while (true) { + if (!(b.$length > 0)) { break; } + _tuple = f.pread(b, off); + m = _tuple[0]; + e = _tuple[1]; + if ((m === 0) && $interfaceIsEqual(e, $ifaceNil)) { + _tmp$2 = n; + _tmp$3 = io.EOF; + n = _tmp$2; + err = _tmp$3; + return [n, err]; + } + if (!($interfaceIsEqual(e, $ifaceNil))) { + err = new PathError.ptr("read", f.file.name, e); + break; + } + n = n + (m) >> 0; + b = $subslice(b, m); + off = (x = new $Int64(0, m), new $Int64(off.$high + x.$high, off.$low + x.$low)); + } + return [n, err]; + }; + File.prototype.ReadAt = function(b, off) { return this.$val.ReadAt(b, off); }; + File.ptr.prototype.Write = function(b) { + var $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, _tuple, b, e, err, f, n; + n = 0; + err = $ifaceNil; + f = this; + if (f === ptrType$1.nil) { + _tmp = 0; + _tmp$1 = $pkg.ErrInvalid; + n = _tmp; + err = _tmp$1; + return [n, err]; + } + _tuple = f.write(b); + 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 = new PathError.ptr("write", f.file.name, e); + } + _tmp$2 = n; + _tmp$3 = err; + n = _tmp$2; + err = _tmp$3; + return [n, err]; + }; + File.prototype.Write = function(b) { return this.$val.Write(b); }; + File.ptr.prototype.WriteAt = function(b, off) { + var $ptr, _tmp, _tmp$1, _tuple, b, e, err, f, m, n, off, x; + n = 0; + err = $ifaceNil; + f = this; + if (f === ptrType$1.nil) { + _tmp = 0; + _tmp$1 = $pkg.ErrInvalid; + n = _tmp; + err = _tmp$1; + return [n, err]; + } + while (true) { + if (!(b.$length > 0)) { break; } + _tuple = f.pwrite(b, off); + m = _tuple[0]; + e = _tuple[1]; + if (!($interfaceIsEqual(e, $ifaceNil))) { + err = new PathError.ptr("write", f.file.name, e); + break; + } + n = n + (m) >> 0; + b = $subslice(b, m); + off = (x = new $Int64(0, m), new $Int64(off.$high + x.$high, off.$low + x.$low)); + } + return [n, err]; + }; + File.prototype.WriteAt = function(b, off) { return this.$val.WriteAt(b, off); }; + File.ptr.prototype.Seek = function(offset, whence) { + var $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tuple, e, err, f, offset, r, ret, whence; + ret = new $Int64(0, 0); + err = $ifaceNil; + f = this; + if (f === ptrType$1.nil) { + _tmp = new $Int64(0, 0); + _tmp$1 = $pkg.ErrInvalid; + ret = _tmp; + err = _tmp$1; + return [ret, err]; + } + _tuple = f.seek(offset, whence); + r = _tuple[0]; + e = _tuple[1]; + if ($interfaceIsEqual(e, $ifaceNil) && !(f.file.dirinfo === ptrType.nil) && !((r.$high === 0 && r.$low === 0))) { + e = new syscall.Errno(21); + } + if (!($interfaceIsEqual(e, $ifaceNil))) { + _tmp$2 = new $Int64(0, 0); + _tmp$3 = new PathError.ptr("seek", f.file.name, e); + ret = _tmp$2; + err = _tmp$3; + return [ret, err]; + } + _tmp$4 = r; + _tmp$5 = $ifaceNil; + ret = _tmp$4; + err = _tmp$5; + return [ret, err]; + }; + File.prototype.Seek = function(offset, whence) { return this.$val.Seek(offset, whence); }; + File.ptr.prototype.WriteString = function(s) { + var $ptr, _tmp, _tmp$1, _tuple, err, f, n, s; + n = 0; + err = $ifaceNil; + f = this; + if (f === ptrType$1.nil) { + _tmp = 0; + _tmp$1 = $pkg.ErrInvalid; + n = _tmp; + err = _tmp$1; + return [n, err]; + } + _tuple = f.Write(new sliceType$1($stringToBytes(s))); + n = _tuple[0]; + err = _tuple[1]; + return [n, err]; + }; + File.prototype.WriteString = function(s) { return this.$val.WriteString(s); }; + File.ptr.prototype.Chdir = function() { + var $ptr, e, f; + f = this; + if (f === ptrType$1.nil) { + return $pkg.ErrInvalid; + } + e = syscall.Fchdir(f.file.fd); + if (!($interfaceIsEqual(e, $ifaceNil))) { + return new PathError.ptr("chdir", f.file.name, e); + } + return $ifaceNil; + }; + File.prototype.Chdir = function() { return this.$val.Chdir(); }; + fixCount = function(n, err) { + var $ptr, err, n; + if (n < 0) { + n = 0; + } + return [n, err]; + }; + sigpipe = function() { + $throwRuntimeError("native function not implemented: os.sigpipe"); + }; + syscallMode = function(i) { + var $ptr, 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 $ptr, e, f, mode; + f = this; + if (f === ptrType$1.nil) { + return $pkg.ErrInvalid; + } + e = syscall.Fchmod(f.file.fd, syscallMode(mode)); + if (!($interfaceIsEqual(e, $ifaceNil))) { + return new PathError.ptr("chmod", f.file.name, e); + } + return $ifaceNil; + }; + File.prototype.Chmod = function(mode) { return this.$val.Chmod(mode); }; + File.ptr.prototype.Chown = function(uid, gid) { + var $ptr, e, f, gid, uid; + f = this; + if (f === ptrType$1.nil) { + return $pkg.ErrInvalid; + } + e = syscall.Fchown(f.file.fd, uid, gid); + if (!($interfaceIsEqual(e, $ifaceNil))) { + return new PathError.ptr("chown", f.file.name, e); + } + return $ifaceNil; + }; + File.prototype.Chown = function(uid, gid) { return this.$val.Chown(uid, gid); }; + File.ptr.prototype.Truncate = function(size) { + var $ptr, e, f, size; + f = this; + if (f === ptrType$1.nil) { + return $pkg.ErrInvalid; + } + e = syscall.Ftruncate(f.file.fd, size); + if (!($interfaceIsEqual(e, $ifaceNil))) { + return new PathError.ptr("truncate", f.file.name, e); + } + return $ifaceNil; + }; + File.prototype.Truncate = function(size) { return this.$val.Truncate(size); }; + File.ptr.prototype.Sync = function() { + var $ptr, e, f; + f = this; + if (f === ptrType$1.nil) { + return $pkg.ErrInvalid; + } + e = syscall.Fsync(f.file.fd); + if (!($interfaceIsEqual(e, $ifaceNil))) { + return NewSyscallError("fsync", e); + } + return $ifaceNil; + }; + File.prototype.Sync = function() { return this.$val.Sync(); }; + File.ptr.prototype.Fd = function() { + var $ptr, f; + f = this; + if (f === ptrType$1.nil) { + return 4294967295; + } + return (f.file.fd >>> 0); + }; + File.prototype.Fd = function() { return this.$val.Fd(); }; + NewFile = function(fd, name) { + var $ptr, f, fd, fdi, name; + fdi = (fd >> 0); + if (fdi < 0) { + return ptrType$1.nil; + } + f = new File.ptr(new file.ptr(fdi, name, ptrType.nil)); + runtime.SetFinalizer(f.file, new funcType$1($methodExpr(ptrType$12, "close"))); + return f; + }; + $pkg.NewFile = NewFile; + epipecheck = function(file$1, e) { + var $ptr, e, file$1; + if ($interfaceIsEqual(e, new syscall.Errno(32)) && ((file$1.file.fd === 1) || (file$1.file.fd === 2))) { + sigpipe(); + } + }; + File.ptr.prototype.Close = function() { + var $ptr, f; + f = this; + if (f === ptrType$1.nil) { + return $pkg.ErrInvalid; + } + return f.file.close(); + }; + File.prototype.Close = function() { return this.$val.Close(); }; + file.ptr.prototype.close = function() { + var $ptr, e, err, file$1; + file$1 = this; + if (file$1 === ptrType$12.nil || file$1.fd < 0) { + return new syscall.Errno(22); + } + err = $ifaceNil; + e = syscall.Close(file$1.fd); + if (!($interfaceIsEqual(e, $ifaceNil))) { + err = new PathError.ptr("close", file$1.name, e); + } + file$1.fd = -1; + runtime.SetFinalizer(file$1, $ifaceNil); + return err; + }; + file.prototype.close = function() { return this.$val.close(); }; + File.ptr.prototype.Stat = function() { + var $ptr, err, f, fs; + f = this; + if (f === ptrType$1.nil) { + return [$ifaceNil, $pkg.ErrInvalid]; + } + fs = new fileStat.ptr("", new $Int64(0, 0), 0, new time.Time.ptr(new $Int64(0, 0), 0, ptrType$13.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.Fstat(f.file.fd, fs.sys); + if (!($interfaceIsEqual(err, $ifaceNil))) { + return [$ifaceNil, new PathError.ptr("stat", f.file.name, err)]; + } + fillFileStatFromSys(fs, f.file.name); + return [fs, $ifaceNil]; + }; + File.prototype.Stat = function() { return this.$val.Stat(); }; + Lstat = function(name) { + var $ptr, err, fs, name; + fs = new fileStat.ptr("", new $Int64(0, 0), 0, new time.Time.ptr(new $Int64(0, 0), 0, ptrType$13.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]; + }; + $pkg.Lstat = Lstat; + File.ptr.prototype.readdir = function(n) { + var $ptr, _i, _r, _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; $ptr = $f.$ptr; _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; _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$2.nil; + err = $ifaceNil; + f = this; + dirname = f.file.name; + if (dirname === "") { + dirname = "."; + } + _tuple = f.Readdirnames(n); + names = _tuple[0]; + err = _tuple[1]; + fi = $makeSlice(sliceType$2, 0, names.$length); + _ref = names; + _i = 0; + /* while (true) { */ case 1: + /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; } + filename = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]); + _r = lstat(dirname + "/" + filename); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple$1 = _r; + fip = _tuple$1[0]; + lerr = _tuple$1[1]; + if (IsNotExist(lerr)) { + _i++; + /* continue; */ $s = 1; continue; + } + if (!($interfaceIsEqual(lerr, $ifaceNil))) { + _tmp = fi; + _tmp$1 = lerr; + fi = _tmp; + err = _tmp$1; + return [fi, err]; + } + fi = $append(fi, fip); + _i++; + /* } */ $s = 1; continue; case 2: + _tmp$2 = fi; + _tmp$3 = err; + fi = _tmp$2; + err = _tmp$3; + return [fi, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: File.ptr.prototype.readdir }; } $f.$ptr = $ptr; $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._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); }; + File.ptr.prototype.read = function(b) { + var $ptr, _tuple, _tuple$1, b, err, f, n; + n = 0; + err = $ifaceNil; + f = this; + if (false && b.$length > 1073741824) { + b = $subslice(b, 0, 1073741824); + } + _tuple$1 = syscall.Read(f.file.fd, b); + _tuple = fixCount(_tuple$1[0], _tuple$1[1]); + n = _tuple[0]; + err = _tuple[1]; + return [n, err]; + }; + File.prototype.read = function(b) { return this.$val.read(b); }; + File.ptr.prototype.pread = function(b, off) { + var $ptr, _tuple, _tuple$1, b, err, f, n, off; + n = 0; + err = $ifaceNil; + f = this; + if (false && b.$length > 1073741824) { + b = $subslice(b, 0, 1073741824); + } + _tuple$1 = syscall.Pread(f.file.fd, b, off); + _tuple = fixCount(_tuple$1[0], _tuple$1[1]); + n = _tuple[0]; + err = _tuple[1]; + return [n, err]; + }; + File.prototype.pread = function(b, off) { return this.$val.pread(b, off); }; + File.ptr.prototype.write = function(b) { + var $ptr, _tmp, _tmp$1, _tuple, _tuple$1, b, bcap, err, err$1, f, m, n; + n = 0; + err = $ifaceNil; + f = this; + while (true) { + bcap = b; + if (false && bcap.$length > 1073741824) { + bcap = $subslice(bcap, 0, 1073741824); + } + _tuple$1 = syscall.Write(f.file.fd, bcap); + _tuple = fixCount(_tuple$1[0], _tuple$1[1]); + m = _tuple[0]; + err$1 = _tuple[1]; + n = n + (m) >> 0; + if (0 < m && m < bcap.$length || $interfaceIsEqual(err$1, new syscall.Errno(4))) { + b = $subslice(b, m); + continue; + } + if (false && !((bcap.$length === b.$length)) && $interfaceIsEqual(err$1, $ifaceNil)) { + b = $subslice(b, m); + continue; + } + _tmp = n; + _tmp$1 = err$1; + n = _tmp; + err = _tmp$1; + return [n, err]; + } + }; + File.prototype.write = function(b) { return this.$val.write(b); }; + File.ptr.prototype.pwrite = function(b, off) { + var $ptr, _tuple, _tuple$1, b, err, f, n, off; + n = 0; + err = $ifaceNil; + f = this; + if (false && b.$length > 1073741824) { + b = $subslice(b, 0, 1073741824); + } + _tuple$1 = syscall.Pwrite(f.file.fd, b, off); + _tuple = fixCount(_tuple$1[0], _tuple$1[1]); + n = _tuple[0]; + err = _tuple[1]; + return [n, err]; + }; + File.prototype.pwrite = function(b, off) { return this.$val.pwrite(b, off); }; + File.ptr.prototype.seek = function(offset, whence) { + var $ptr, _tuple, err, f, offset, ret, whence; + ret = new $Int64(0, 0); + err = $ifaceNil; + f = this; + _tuple = syscall.Seek(f.file.fd, offset, whence); + ret = _tuple[0]; + err = _tuple[1]; + return [ret, err]; + }; + File.prototype.seek = function(offset, whence) { return this.$val.seek(offset, whence); }; + basename = function(name) { + var $ptr, i, name; + i = name.length - 1 >> 0; + while (true) { + if (!(i > 0 && (name.charCodeAt(i) === 47))) { break; } + name = name.substring(0, i); + i = i - (1) >> 0; + } + i = i - (1) >> 0; + while (true) { + if (!(i >= 0)) { break; } + if (name.charCodeAt(i) === 47) { + name = name.substring((i + 1 >> 0)); + break; + } + i = i - (1) >> 0; + } + return name; + }; + init$1 = function() { + var $ptr; + if (false) { + return; + } + $pkg.Args = runtime_args(); + }; + Exit = function(code) { + var $ptr, code; + if (code === 0) { + runtime_beforeExit(); + } + syscall.Exit(code); + }; + $pkg.Exit = Exit; + fillFileStatFromSys = function(fs, name) { + var $ptr, _1, fs, name; + fs.name = basename(name); + fs.size = fs.sys.Size; + time.Time.copy(fs.modTime, timespecToTime(fs.sys.Mtim)); + 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 $ptr, ts; + ts = $clone(ts, syscall.Timespec); + return time.Unix(ts.Sec, ts.Nsec); + }; + FileMode.prototype.String = function() { + var $ptr, _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$5.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") : 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") : 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") : buf[w] = (c$1 << 24 >>> 24)); + } else { + ((w < 0 || w >= buf.length) ? $throwRuntimeError("index out of range") : buf[w] = 45); + } + w = w + (1) >> 0; + _i$1 += _rune$1[1]; + } + return $bytesToString($subslice(new sliceType$1(buf), 0, w)); + }; + $ptrType(FileMode).prototype.String = function() { return new FileMode(this.$get()).String(); }; + FileMode.prototype.IsDir = function() { + var $ptr, 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 $ptr, m; + m = this.$val; + return ((m & 2399141888) >>> 0) === 0; + }; + $ptrType(FileMode).prototype.IsRegular = function() { return new FileMode(this.$get()).IsRegular(); }; + FileMode.prototype.Perm = function() { + var $ptr, 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 $ptr, fs; + fs = this; + return fs.name; + }; + fileStat.prototype.Name = function() { return this.$val.Name(); }; + fileStat.ptr.prototype.IsDir = function() { + var $ptr, fs; + fs = this; + return new FileMode(fs.Mode()).IsDir(); + }; + fileStat.prototype.IsDir = function() { return this.$val.IsDir(); }; + fileStat.ptr.prototype.Size = function() { + var $ptr, fs; + fs = this; + return fs.size; + }; + fileStat.prototype.Size = function() { return this.$val.Size(); }; + fileStat.ptr.prototype.Mode = function() { + var $ptr, fs; + fs = this; + return fs.mode; + }; + fileStat.prototype.Mode = function() { return this.$val.Mode(); }; + fileStat.ptr.prototype.ModTime = function() { + var $ptr, fs; + fs = this; + return fs.modTime; + }; + fileStat.prototype.ModTime = function() { return this.$val.ModTime(); }; + fileStat.ptr.prototype.Sys = function() { + var $ptr, fs; + fs = this; + return fs.sys; + }; + fileStat.prototype.Sys = function() { return this.$val.Sys(); }; + ptrType$2.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}]; + ptrType$4.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}]; + ptrType$3.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}]; + ptrType$1.methods = [{prop: "readdirnames", name: "readdirnames", pkg: "os", typ: $funcType([$Int], [sliceType, $error], false)}, {prop: "Readdir", name: "Readdir", pkg: "", typ: $funcType([$Int], [sliceType$2, $error], false)}, {prop: "Readdirnames", name: "Readdirnames", pkg: "", typ: $funcType([$Int], [sliceType, $error], false)}, {prop: "Name", name: "Name", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Read", name: "Read", pkg: "", typ: $funcType([sliceType$1], [$Int, $error], false)}, {prop: "ReadAt", name: "ReadAt", pkg: "", typ: $funcType([sliceType$1, $Int64], [$Int, $error], false)}, {prop: "Write", name: "Write", pkg: "", typ: $funcType([sliceType$1], [$Int, $error], false)}, {prop: "WriteAt", name: "WriteAt", pkg: "", typ: $funcType([sliceType$1, $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: "Chdir", name: "Chdir", pkg: "", typ: $funcType([], [$error], false)}, {prop: "Chmod", name: "Chmod", pkg: "", 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: "Fd", name: "Fd", pkg: "", typ: $funcType([], [$Uintptr], false)}, {prop: "Close", name: "Close", pkg: "", typ: $funcType([], [$error], false)}, {prop: "Stat", name: "Stat", pkg: "", typ: $funcType([], [FileInfo, $error], false)}, {prop: "readdir", name: "readdir", pkg: "os", typ: $funcType([$Int], [sliceType$2, $error], false)}, {prop: "read", name: "read", pkg: "os", typ: $funcType([sliceType$1], [$Int, $error], false)}, {prop: "pread", name: "pread", pkg: "os", typ: $funcType([sliceType$1, $Int64], [$Int, $error], false)}, {prop: "write", name: "write", pkg: "os", typ: $funcType([sliceType$1], [$Int, $error], false)}, {prop: "pwrite", name: "pwrite", pkg: "os", typ: $funcType([sliceType$1, $Int64], [$Int, $error], false)}, {prop: "seek", name: "seek", pkg: "os", typ: $funcType([$Int64, $Int], [$Int64, $error], false)}]; + ptrType$12.methods = [{prop: "close", name: "close", pkg: "os", typ: $funcType([], [$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$15.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)}]; + PathError.init([{prop: "Op", name: "Op", pkg: "", typ: $String, tag: ""}, {prop: "Path", name: "Path", pkg: "", typ: $String, tag: ""}, {prop: "Err", name: "Err", pkg: "", typ: $error, tag: ""}]); + SyscallError.init([{prop: "Syscall", name: "Syscall", pkg: "", typ: $String, tag: ""}, {prop: "Err", name: "Err", pkg: "", typ: $error, tag: ""}]); + LinkError.init([{prop: "Op", name: "Op", pkg: "", typ: $String, tag: ""}, {prop: "Old", name: "Old", pkg: "", typ: $String, tag: ""}, {prop: "New", name: "New", pkg: "", typ: $String, tag: ""}, {prop: "Err", name: "Err", pkg: "", typ: $error, tag: ""}]); + File.init([{prop: "file", name: "", pkg: "os", typ: ptrType$12, tag: ""}]); + file.init([{prop: "fd", name: "fd", pkg: "os", typ: $Int, tag: ""}, {prop: "name", name: "name", pkg: "os", typ: $String, tag: ""}, {prop: "dirinfo", name: "dirinfo", pkg: "os", typ: ptrType, tag: ""}]); + dirInfo.init([{prop: "buf", name: "buf", pkg: "os", typ: sliceType$1, tag: ""}, {prop: "nbuf", name: "nbuf", pkg: "os", typ: $Int, tag: ""}, {prop: "bufp", name: "bufp", pkg: "os", typ: $Int, 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([{prop: "name", name: "name", pkg: "os", typ: $String, tag: ""}, {prop: "size", name: "size", pkg: "os", typ: $Int64, tag: ""}, {prop: "mode", name: "mode", pkg: "os", typ: FileMode, tag: ""}, {prop: "modTime", name: "modTime", pkg: "os", typ: time.Time, tag: ""}, {prop: "sys", name: "sys", pkg: "os", 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 = io.$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 = sync.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = atomic.$init(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = syscall.$init(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = time.$init(); /* */ $s = 8; case 8: 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"); + 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["reflect"] = (function() { + var $pkg = {}, $init, errors, js, math, runtime, strconv, sync, mapIter, Type, Kind, rtype, typeAlg, method, uncommonType, ChanDir, arrayType, chanType, funcType, imethod, interfaceType, mapType, ptrType, sliceType, structField, structType, Method, StructField, StructTag, fieldScan, Value, flag, ValueError, nonEmptyInterface, ptrType$1, sliceType$1, sliceType$2, ptrType$3, funcType$1, sliceType$3, ptrType$4, ptrType$5, ptrType$6, ptrType$7, sliceType$4, sliceType$5, sliceType$6, structType$6, sliceType$7, sliceType$8, ptrType$8, arrayType$1, structType$7, ptrType$9, sliceType$9, ptrType$10, ptrType$11, ptrType$12, sliceType$11, sliceType$12, ptrType$13, sliceType$13, ptrType$18, sliceType$15, funcType$3, funcType$4, funcType$5, arrayType$3, ptrType$20, initialized, stringPtrMap, callHelper, jsObjectPtr, selectHelper, kindNames, uint8Type, init, jsType, reflectType, setKindType, newStringPtr, isWrapped, copyStruct, makeValue, MakeSlice, TypeOf, ValueOf, SliceOf, Zero, unsafe_New, makeInt, typedmemmove, keyFor, mapaccess, mapassign, mapdelete, mapiterinit, mapiterkey, mapiternext, maplen, cvtDirect, methodReceiver, valueInterface, ifaceE2I, methodName, makeMethodValue, wrapJsObject, unwrapJsObject, getJsTag, chanrecv, chansend, PtrTo, implements$1, directlyAssignable, haveIdenticalUnderlyingType, toType, ifaceIndir, 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"]; + mapIter = $pkg.mapIter = $newType(0, $kindStruct, "reflect.mapIter", "mapIter", "reflect", function(t_, m_, keys_, i_) { + this.$val = this; + if (arguments.length === 0) { + this.t = $ifaceNil; + this.m = null; + this.keys = null; + this.i = 0; + return; + } + this.t = t_; + this.m = m_; + this.keys = keys_; + this.i = i_; + }); + Type = $pkg.Type = $newType(8, $kindInterface, "reflect.Type", "Type", "reflect", null); + Kind = $pkg.Kind = $newType(4, $kindUint, "reflect.Kind", "Kind", "reflect", null); + rtype = $pkg.rtype = $newType(0, $kindStruct, "reflect.rtype", "rtype", "reflect", function(size_, ptrdata_, hash_, _$3_, align_, fieldAlign_, kind_, alg_, gcdata_, string_, uncommonType_, ptrToThis_) { + this.$val = this; + if (arguments.length === 0) { + this.size = 0; + this.ptrdata = 0; + this.hash = 0; + this._$3 = 0; + this.align = 0; + this.fieldAlign = 0; + this.kind = 0; + this.alg = ptrType$4.nil; + this.gcdata = ptrType$5.nil; + this.string = ptrType$6.nil; + this.uncommonType = ptrType$7.nil; + this.ptrToThis = ptrType$1.nil; + return; + } + this.size = size_; + this.ptrdata = ptrdata_; + this.hash = hash_; + this._$3 = _$3_; + this.align = align_; + this.fieldAlign = fieldAlign_; + this.kind = kind_; + this.alg = alg_; + this.gcdata = gcdata_; + this.string = string_; + this.uncommonType = uncommonType_; + this.ptrToThis = ptrToThis_; + }); + typeAlg = $pkg.typeAlg = $newType(0, $kindStruct, "reflect.typeAlg", "typeAlg", "reflect", 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", "method", "reflect", function(name_, pkgPath_, mtyp_, typ_, ifn_, tfn_) { + this.$val = this; + if (arguments.length === 0) { + this.name = ptrType$6.nil; + this.pkgPath = ptrType$6.nil; + this.mtyp = ptrType$1.nil; + this.typ = ptrType$1.nil; + this.ifn = 0; + this.tfn = 0; + return; + } + this.name = name_; + this.pkgPath = pkgPath_; + this.mtyp = mtyp_; + this.typ = typ_; + this.ifn = ifn_; + this.tfn = tfn_; + }); + uncommonType = $pkg.uncommonType = $newType(0, $kindStruct, "reflect.uncommonType", "uncommonType", "reflect", function(name_, pkgPath_, methods_) { + this.$val = this; + if (arguments.length === 0) { + this.name = ptrType$6.nil; + this.pkgPath = ptrType$6.nil; + this.methods = sliceType$4.nil; + return; + } + this.name = name_; + this.pkgPath = pkgPath_; + this.methods = methods_; + }); + ChanDir = $pkg.ChanDir = $newType(4, $kindInt, "reflect.ChanDir", "ChanDir", "reflect", null); + arrayType = $pkg.arrayType = $newType(0, $kindStruct, "reflect.arrayType", "arrayType", "reflect", 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$4.nil, ptrType$5.nil, ptrType$6.nil, ptrType$7.nil, ptrType$1.nil); + 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", "chanType", "reflect", function(rtype_, elem_, dir_) { + this.$val = this; + if (arguments.length === 0) { + this.rtype = new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$4.nil, ptrType$5.nil, ptrType$6.nil, ptrType$7.nil, ptrType$1.nil); + this.elem = ptrType$1.nil; + this.dir = 0; + return; + } + this.rtype = rtype_; + this.elem = elem_; + this.dir = dir_; + }); + funcType = $pkg.funcType = $newType(0, $kindStruct, "reflect.funcType", "funcType", "reflect", function(rtype_, dotdotdot_, in$2_, out_) { + this.$val = this; + if (arguments.length === 0) { + this.rtype = new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$4.nil, ptrType$5.nil, ptrType$6.nil, ptrType$7.nil, ptrType$1.nil); + this.dotdotdot = false; + this.in$2 = sliceType$1.nil; + this.out = sliceType$1.nil; + return; + } + this.rtype = rtype_; + this.dotdotdot = dotdotdot_; + this.in$2 = in$2_; + this.out = out_; + }); + imethod = $pkg.imethod = $newType(0, $kindStruct, "reflect.imethod", "imethod", "reflect", function(name_, pkgPath_, typ_) { + this.$val = this; + if (arguments.length === 0) { + this.name = ptrType$6.nil; + this.pkgPath = ptrType$6.nil; + this.typ = ptrType$1.nil; + return; + } + this.name = name_; + this.pkgPath = pkgPath_; + this.typ = typ_; + }); + interfaceType = $pkg.interfaceType = $newType(0, $kindStruct, "reflect.interfaceType", "interfaceType", "reflect", function(rtype_, methods_) { + this.$val = this; + if (arguments.length === 0) { + this.rtype = new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$4.nil, ptrType$5.nil, ptrType$6.nil, ptrType$7.nil, ptrType$1.nil); + this.methods = sliceType$5.nil; + return; + } + this.rtype = rtype_; + this.methods = methods_; + }); + mapType = $pkg.mapType = $newType(0, $kindStruct, "reflect.mapType", "mapType", "reflect", function(rtype_, key_, elem_, bucket_, hmap_, keysize_, indirectkey_, valuesize_, indirectvalue_, bucketsize_, reflexivekey_, needkeyupdate_) { + this.$val = this; + if (arguments.length === 0) { + this.rtype = new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$4.nil, ptrType$5.nil, ptrType$6.nil, ptrType$7.nil, ptrType$1.nil); + this.key = ptrType$1.nil; + this.elem = ptrType$1.nil; + this.bucket = ptrType$1.nil; + this.hmap = ptrType$1.nil; + this.keysize = 0; + this.indirectkey = 0; + this.valuesize = 0; + this.indirectvalue = 0; + this.bucketsize = 0; + this.reflexivekey = false; + this.needkeyupdate = false; + return; + } + this.rtype = rtype_; + this.key = key_; + this.elem = elem_; + this.bucket = bucket_; + this.hmap = hmap_; + this.keysize = keysize_; + this.indirectkey = indirectkey_; + this.valuesize = valuesize_; + this.indirectvalue = indirectvalue_; + this.bucketsize = bucketsize_; + this.reflexivekey = reflexivekey_; + this.needkeyupdate = needkeyupdate_; + }); + ptrType = $pkg.ptrType = $newType(0, $kindStruct, "reflect.ptrType", "ptrType", "reflect", function(rtype_, elem_) { + this.$val = this; + if (arguments.length === 0) { + this.rtype = new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$4.nil, ptrType$5.nil, ptrType$6.nil, ptrType$7.nil, ptrType$1.nil); + this.elem = ptrType$1.nil; + return; + } + this.rtype = rtype_; + this.elem = elem_; + }); + sliceType = $pkg.sliceType = $newType(0, $kindStruct, "reflect.sliceType", "sliceType", "reflect", function(rtype_, elem_) { + this.$val = this; + if (arguments.length === 0) { + this.rtype = new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$4.nil, ptrType$5.nil, ptrType$6.nil, ptrType$7.nil, ptrType$1.nil); + this.elem = ptrType$1.nil; + return; + } + this.rtype = rtype_; + this.elem = elem_; + }); + structField = $pkg.structField = $newType(0, $kindStruct, "reflect.structField", "structField", "reflect", function(name_, pkgPath_, typ_, tag_, offset_) { + this.$val = this; + if (arguments.length === 0) { + this.name = ptrType$6.nil; + this.pkgPath = ptrType$6.nil; + this.typ = ptrType$1.nil; + this.tag = ptrType$6.nil; + this.offset = 0; + return; + } + this.name = name_; + this.pkgPath = pkgPath_; + this.typ = typ_; + this.tag = tag_; + this.offset = offset_; + }); + structType = $pkg.structType = $newType(0, $kindStruct, "reflect.structType", "structType", "reflect", function(rtype_, fields_) { + this.$val = this; + if (arguments.length === 0) { + this.rtype = new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$4.nil, ptrType$5.nil, ptrType$6.nil, ptrType$7.nil, ptrType$1.nil); + this.fields = sliceType$6.nil; + return; + } + this.rtype = rtype_; + this.fields = fields_; + }); + Method = $pkg.Method = $newType(0, $kindStruct, "reflect.Method", "Method", "reflect", 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_; + }); + StructField = $pkg.StructField = $newType(0, $kindStruct, "reflect.StructField", "StructField", "reflect", 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$11.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", "StructTag", "reflect", null); + fieldScan = $pkg.fieldScan = $newType(0, $kindStruct, "reflect.fieldScan", "fieldScan", "reflect", function(typ_, index_) { + this.$val = this; + if (arguments.length === 0) { + this.typ = ptrType$13.nil; + this.index = sliceType$11.nil; + return; + } + this.typ = typ_; + this.index = index_; + }); + Value = $pkg.Value = $newType(0, $kindStruct, "reflect.Value", "Value", "reflect", 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", "flag", "reflect", null); + ValueError = $pkg.ValueError = $newType(0, $kindStruct, "reflect.ValueError", "ValueError", "reflect", function(Method_, Kind_) { + this.$val = this; + if (arguments.length === 0) { + this.Method = ""; + this.Kind = 0; + return; + } + this.Method = Method_; + this.Kind = Kind_; + }); + nonEmptyInterface = $pkg.nonEmptyInterface = $newType(0, $kindStruct, "reflect.nonEmptyInterface", "nonEmptyInterface", "reflect", function(itab_, word_) { + this.$val = this; + if (arguments.length === 0) { + this.itab = ptrType$9.nil; + this.word = 0; + return; + } + this.itab = itab_; + this.word = word_; + }); + ptrType$1 = $ptrType(rtype); + sliceType$1 = $sliceType(ptrType$1); + sliceType$2 = $sliceType($emptyInterface); + ptrType$3 = $ptrType(js.Object); + funcType$1 = $funcType([sliceType$2], [ptrType$3], true); + sliceType$3 = $sliceType($String); + ptrType$4 = $ptrType(typeAlg); + ptrType$5 = $ptrType($Uint8); + ptrType$6 = $ptrType($String); + ptrType$7 = $ptrType(uncommonType); + sliceType$4 = $sliceType(method); + sliceType$5 = $sliceType(imethod); + sliceType$6 = $sliceType(structField); + structType$6 = $structType([{prop: "str", name: "str", pkg: "reflect", typ: $String, tag: ""}]); + sliceType$7 = $sliceType(ptrType$3); + sliceType$8 = $sliceType(Value); + ptrType$8 = $ptrType(nonEmptyInterface); + arrayType$1 = $arrayType($UnsafePointer, 100000); + structType$7 = $structType([{prop: "ityp", name: "ityp", pkg: "reflect", typ: ptrType$1, tag: ""}, {prop: "typ", name: "typ", pkg: "reflect", typ: ptrType$1, tag: ""}, {prop: "link", name: "link", pkg: "reflect", typ: $UnsafePointer, tag: ""}, {prop: "bad", name: "bad", pkg: "reflect", typ: $Int32, tag: ""}, {prop: "unused", name: "unused", pkg: "reflect", typ: $Int32, tag: ""}, {prop: "fun", name: "fun", pkg: "reflect", typ: arrayType$1, tag: ""}]); + ptrType$9 = $ptrType(structType$7); + sliceType$9 = $sliceType(sliceType$7); + ptrType$10 = $ptrType(method); + ptrType$11 = $ptrType(interfaceType); + ptrType$12 = $ptrType(imethod); + sliceType$11 = $sliceType($Int); + sliceType$12 = $sliceType(fieldScan); + ptrType$13 = $ptrType(structType); + sliceType$13 = $sliceType($Uint8); + ptrType$18 = $ptrType($UnsafePointer); + sliceType$15 = $sliceType($Int32); + funcType$3 = $funcType([$String], [$Bool], false); + funcType$4 = $funcType([$UnsafePointer, $Uintptr], [$Uintptr], false); + funcType$5 = $funcType([$UnsafePointer, $UnsafePointer], [$Bool], false); + arrayType$3 = $arrayType($Uintptr, 2); + ptrType$20 = $ptrType(ValueError); + init = function() { + var $ptr, 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; $ptr = $f.$ptr; 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 $ptr, i; + }); + $r = used((x = new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$4.nil, ptrType$5.nil, ptrType$6.nil, ptrType$7.nil, ptrType$1.nil), 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(ptrType$6.nil, ptrType$6.nil, sliceType$4.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(ptrType$6.nil, ptrType$6.nil, ptrType$1.nil, ptrType$1.nil, 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$4.nil, ptrType$5.nil, ptrType$6.nil, ptrType$7.nil, ptrType$1.nil), 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$4.nil, ptrType$5.nil, ptrType$6.nil, ptrType$7.nil, ptrType$1.nil), 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$4.nil, ptrType$5.nil, ptrType$6.nil, ptrType$7.nil, ptrType$1.nil), false, sliceType$1.nil, sliceType$1.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$4.nil, ptrType$5.nil, ptrType$6.nil, ptrType$7.nil, ptrType$1.nil), sliceType$5.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$4.nil, ptrType$5.nil, ptrType$6.nil, ptrType$7.nil, ptrType$1.nil), ptrType$1.nil, ptrType$1.nil, ptrType$1.nil, ptrType$1.nil, 0, 0, 0, 0, 0, false, false), 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$4.nil, ptrType$5.nil, ptrType$6.nil, ptrType$7.nil, ptrType$1.nil), 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$4.nil, ptrType$5.nil, ptrType$6.nil, ptrType$7.nil, ptrType$1.nil), 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$4.nil, ptrType$5.nil, ptrType$6.nil, ptrType$7.nil, ptrType$1.nil), sliceType$6.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(ptrType$6.nil, ptrType$6.nil, ptrType$1.nil), 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(ptrType$6.nil, ptrType$6.nil, ptrType$1.nil, ptrType$6.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; case -1: } return; } if ($f === undefined) { $f = { $blk: init }; } $f.$ptr = $ptr; $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 $ptr, typ; + return typ.jsType; + }; + reflectType = function(typ) { + var $ptr, _1, _i, _i$1, _i$2, _i$3, _i$4, _ref, _ref$1, _ref$2, _ref$3, _ref$4, dir, f, fields, i, i$1, i$2, i$3, i$4, imethods, in$1, m, m$1, methodSet, methods, out, params, reflectFields, reflectMethods, results, rt, t, typ; + 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$4.nil, ptrType$5.nil, newStringPtr(typ.string), ptrType$7.nil, ptrType$1.nil); + rt.jsType = typ; + typ.reflectType = rt; + methodSet = $methodSet(typ); + if (!($internalize(typ.typeName, $String) === "") || !(($parseInt(methodSet.length) === 0))) { + reflectMethods = $makeSlice(sliceType$4, $parseInt(methodSet.length)); + _ref = reflectMethods; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + m = methodSet[i]; + t = m.typ; + method.copy(((i < 0 || i >= reflectMethods.$length) ? $throwRuntimeError("index out of range") : reflectMethods.$array[reflectMethods.$offset + i]), new method.ptr(newStringPtr(m.name), newStringPtr(m.pkg), reflectType(t), reflectType($funcType(new ($global.Array)(typ).concat(t.params), t.results, t.variadic)), 0, 0)); + _i++; + } + rt.uncommonType = new uncommonType.ptr(newStringPtr(typ.typeName), newStringPtr(typ.pkg), reflectMethods); + rt.uncommonType.jsType = typ; + } + _1 = rt.Kind(); + if (_1 === (17)) { + setKindType(rt, new arrayType.ptr(new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$4.nil, ptrType$5.nil, ptrType$6.nil, ptrType$7.nil, ptrType$1.nil), 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$4.nil, ptrType$5.nil, ptrType$6.nil, ptrType$7.nil, ptrType$1.nil), reflectType(typ.elem), (dir >>> 0))); + } else if (_1 === (19)) { + params = typ.params; + in$1 = $makeSlice(sliceType$1, $parseInt(params.length)); + _ref$1 = in$1; + _i$1 = 0; + while (true) { + if (!(_i$1 < _ref$1.$length)) { break; } + i$1 = _i$1; + ((i$1 < 0 || i$1 >= in$1.$length) ? $throwRuntimeError("index out of range") : in$1.$array[in$1.$offset + i$1] = reflectType(params[i$1])); + _i$1++; + } + results = typ.results; + out = $makeSlice(sliceType$1, $parseInt(results.length)); + _ref$2 = out; + _i$2 = 0; + while (true) { + if (!(_i$2 < _ref$2.$length)) { break; } + i$2 = _i$2; + ((i$2 < 0 || i$2 >= out.$length) ? $throwRuntimeError("index out of range") : out.$array[out.$offset + i$2] = reflectType(results[i$2])); + _i$2++; + } + setKindType(rt, new funcType.ptr($clone(rt, rtype), !!(typ.variadic), in$1, out)); + } else if (_1 === (20)) { + methods = typ.methods; + imethods = $makeSlice(sliceType$5, $parseInt(methods.length)); + _ref$3 = imethods; + _i$3 = 0; + while (true) { + if (!(_i$3 < _ref$3.$length)) { break; } + i$3 = _i$3; + m$1 = methods[i$3]; + imethod.copy(((i$3 < 0 || i$3 >= imethods.$length) ? $throwRuntimeError("index out of range") : imethods.$array[imethods.$offset + i$3]), new imethod.ptr(newStringPtr(m$1.name), newStringPtr(m$1.pkg), reflectType(m$1.typ))); + _i$3++; + } + setKindType(rt, new interfaceType.ptr($clone(rt, rtype), imethods)); + } else if (_1 === (21)) { + setKindType(rt, new mapType.ptr(new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$4.nil, ptrType$5.nil, ptrType$6.nil, ptrType$7.nil, ptrType$1.nil), reflectType(typ.key), reflectType(typ.elem), ptrType$1.nil, ptrType$1.nil, 0, 0, 0, 0, 0, false, false)); + } else if (_1 === (22)) { + setKindType(rt, new ptrType.ptr(new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$4.nil, ptrType$5.nil, ptrType$6.nil, ptrType$7.nil, ptrType$1.nil), reflectType(typ.elem))); + } else if (_1 === (23)) { + setKindType(rt, new sliceType.ptr(new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$4.nil, ptrType$5.nil, ptrType$6.nil, ptrType$7.nil, ptrType$1.nil), reflectType(typ.elem))); + } else if (_1 === (25)) { + fields = typ.fields; + reflectFields = $makeSlice(sliceType$6, $parseInt(fields.length)); + _ref$4 = reflectFields; + _i$4 = 0; + while (true) { + if (!(_i$4 < _ref$4.$length)) { break; } + i$4 = _i$4; + f = fields[i$4]; + structField.copy(((i$4 < 0 || i$4 >= reflectFields.$length) ? $throwRuntimeError("index out of range") : reflectFields.$array[reflectFields.$offset + i$4]), new structField.ptr(newStringPtr(f.name), newStringPtr(f.pkg), reflectType(f.typ), newStringPtr(f.tag), (i$4 >>> 0))); + _i$4++; + } + setKindType(rt, new structType.ptr($clone(rt, rtype), reflectFields)); + } + } + return typ.reflectType; + }; + setKindType = function(rt, kindType) { + var $ptr, kindType, rt; + rt.kindType = kindType; + kindType.rtype = rt; + }; + newStringPtr = function(strObj) { + var $ptr, _entry, _key, _tuple, c, ok, ptr, str, str$24ptr, strObj; + c = new structType$6.ptr(""); + c.str = strObj; + str = c.str; + if (str === "") { + return ptrType$6.nil; + } + _tuple = (_entry = stringPtrMap[$String.keyFor(str)], _entry !== undefined ? [_entry.v, true] : [ptrType$6.nil, false]); + ptr = _tuple[0]; + ok = _tuple[1]; + if (!ok) { + ptr = (str$24ptr || (str$24ptr = new ptrType$6(function() { return str; }, function($v) { str = $v; }))); + _key = str; (stringPtrMap || $throwRuntimeError("assignment to entry in nil map"))[$String.keyFor(_key)] = { k: _key, v: ptr }; + } + return ptr; + }; + isWrapped = function(typ) { + var $ptr, typ; + return !!(jsType(typ).wrapped); + }; + copyStruct = function(dst, src, typ) { + var $ptr, 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 $ptr, _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; $ptr = $f.$ptr; _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 = 10; case 10: + return new Value.ptr(rt, v, (fl | (_r$4 >>> 0)) >>> 0); + /* } */ case 3: + _r$5 = t.Kind(); /* */ $s = 11; case 11: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + /* */ $s = 12; case 12: + 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.$ptr = $ptr; $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 $ptr, _r, _r$1, cap, len, typ, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _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 $ptr, _r$1, _r$2, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _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 = 3; case 3: + return _r$2.zero(); + /* */ } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $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 = 5; case 5: + return _r$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: MakeSlice }; } $f.$ptr = $ptr; $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 $ptr, i; + if (!initialized) { + return new rtype.ptr(0, 0, 0, 0, 0, 0, 0, ptrType$4.nil, ptrType$5.nil, ptrType$6.nil, ptrType$7.nil, ptrType$1.nil); + } + if ($interfaceIsEqual(i, $ifaceNil)) { + return $ifaceNil; + } + return reflectType(i.constructor); + }; + $pkg.TypeOf = TypeOf; + ValueOf = function(i) { + var $ptr, _r, i, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; i = $f.i; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + if ($interfaceIsEqual(i, $ifaceNil)) { + 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 = 2; case 2: + return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: ValueOf }; } $f.$ptr = $ptr; $f._r = _r; $f.i = i; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.ValueOf = ValueOf; + rtype.ptr.prototype.ptrTo = function() { + var $ptr, t; + t = this; + return reflectType($ptrType(jsType(t))); + }; + rtype.prototype.ptrTo = function() { return this.$val.ptrTo(); }; + SliceOf = function(t) { + var $ptr, t; + return reflectType($sliceType(jsType(t))); + }; + $pkg.SliceOf = SliceOf; + Zero = function(typ) { + var $ptr, _r, typ, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _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 = 2; case 2: + return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: Zero }; } $f.$ptr = $ptr; $f._r = _r; $f.typ = typ; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.Zero = Zero; + unsafe_New = function(typ) { + var $ptr, _3, typ; + _3 = typ.Kind(); + if (_3 === (25)) { + return new (jsType(typ).ptr)(); + } else if (_3 === (17)) { + return jsType(typ).zero(); + } else { + return $newDataPointer(jsType(typ).zero(), jsType(typ.ptrTo())); + } + }; + makeInt = function(f, bits, t) { + var $ptr, _4, _r, bits, f, ptr, t, typ, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _4 = $f._4; _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); + _4 = typ.Kind(); + if (_4 === (3)) { + ptr.$set((bits.$low << 24 >> 24)); + } else if (_4 === (4)) { + ptr.$set((bits.$low << 16 >> 16)); + } else if ((_4 === (2)) || (_4 === (5))) { + ptr.$set((bits.$low >> 0)); + } else if (_4 === (6)) { + ptr.$set(new $Int64(bits.$high, bits.$low)); + } else if (_4 === (8)) { + ptr.$set((bits.$low << 24 >>> 24)); + } else if (_4 === (9)) { + ptr.$set((bits.$low << 16 >>> 16)); + } else if ((_4 === (7)) || (_4 === (10)) || (_4 === (12))) { + ptr.$set((bits.$low >>> 0)); + } else if (_4 === (11)) { + ptr.$set(bits); + } + return new Value.ptr(typ, ptr, (((f | 128) >>> 0) | (typ.Kind() >>> 0)) >>> 0); + /* */ } return; } if ($f === undefined) { $f = { $blk: makeInt }; } $f.$ptr = $ptr; $f._4 = _4; $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 $ptr, dst, src, t; + dst.$set(src.$get()); + }; + keyFor = function(t, key) { + var $ptr, 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 $ptr, _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 $ptr, _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; $ptr = $f.$ptr; _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; case -1: } return; } if ($f === undefined) { $f = { $blk: mapassign }; } $f.$ptr = $ptr; $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 $ptr, _tuple, k, key, m, t; + _tuple = keyFor(t, key); + k = _tuple[1]; + delete m[$externalize(k, $String)]; + }; + mapiterinit = function(t, m) { + var $ptr, m, t; + return new mapIter.ptr(t, m, $keys(m), 0); + }; + mapiterkey = function(it) { + var $ptr, _r, _r$1, _r$2, it, iter, k, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; it = $f.it; iter = $f.iter; k = $f.k; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + iter = it; + k = iter.keys[iter.i]; + _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 = 4; case 4: + return $newDataPointer(iter.m[$externalize($internalize(k, $String), $String)].k, _r$2); + /* */ } return; } if ($f === undefined) { $f = { $blk: mapiterkey }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.it = it; $f.iter = iter; $f.k = k; $f.$s = $s; $f.$r = $r; return $f; + }; + mapiternext = function(it) { + var $ptr, it, iter; + iter = it; + iter.i = iter.i + (1) >> 0; + }; + maplen = function(m) { + var $ptr, m; + return $parseInt($keys(m).length); + }; + cvtDirect = function(v, typ) { + var $ptr, _6, _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; $ptr = $f.$ptr; _6 = $f._6; _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: + v = v; + srcVal = v.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 = 4; case 4: + return _r; + /* } */ case 2: + val = null; + _r$1 = typ.Kind(); /* */ $s = 6; case 6: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + k = _r$1; + _6 = k; + /* */ if (_6 === (23)) { $s = 7; continue; } + /* */ if (_6 === (22)) { $s = 8; continue; } + /* */ if (_6 === (25)) { $s = 9; continue; } + /* */ if ((_6 === (17)) || (_6 === (1)) || (_6 === (18)) || (_6 === (19)) || (_6 === (20)) || (_6 === (21)) || (_6 === (24))) { $s = 10; continue; } + /* */ $s = 11; continue; + /* if (_6 === (23)) { */ case 7: + 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 = 12; continue; + /* } else if (_6 === (22)) { */ case 8: + _r$2 = typ.Elem(); /* */ $s = 15; case 15: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _r$3 = _r$2.Kind(); /* */ $s = 16; case 16: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + /* */ if (_r$3 === 25) { $s = 13; continue; } + /* */ $s = 14; continue; + /* if (_r$3 === 25) { */ case 13: + _r$4 = typ.Elem(); /* */ $s = 19; case 19: 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 = 17; continue; } + /* */ $s = 18; continue; + /* if ($interfaceIsEqual(_r$4, v.typ.Elem())) { */ case 17: + val = srcVal; + /* break; */ $s = 5; continue; + /* } */ case 18: + val = new (jsType(typ))(); + _arg = val; + _arg$1 = srcVal; + _r$5 = typ.Elem(); /* */ $s = 20; case 20: 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 = 21; case 21: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* break; */ $s = 5; continue; + /* } */ case 14: + val = new (jsType(typ))(srcVal.$get, srcVal.$set); + $s = 12; continue; + /* } else if (_6 === (25)) { */ case 9: + val = new (jsType(typ).ptr)(); + copyStruct(val, srcVal, typ); + $s = 12; continue; + /* } else if ((_6 === (17)) || (_6 === (1)) || (_6 === (18)) || (_6 === (19)) || (_6 === (20)) || (_6 === (21)) || (_6 === (24))) { */ case 10: + val = v.ptr; + $s = 12; continue; + /* } else { */ case 11: + $panic(new ValueError.ptr("reflect.Convert", k)); + /* } */ case 12: + case 5: + _r$6 = typ.common(); /* */ $s = 22; case 22: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + _r$7 = typ.Kind(); /* */ $s = 23; case 23: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } + /* */ $s = 24; case 24: + return new Value.ptr(_r$6, val, (((v.flag & 224) >>> 0) | (_r$7 >>> 0)) >>> 0); + /* */ } return; } if ($f === undefined) { $f = { $blk: cvtDirect }; } $f.$ptr = $ptr; $f._6 = _6; $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 $ptr, fn, i, iface, m, m$1, op, prop, rcvr, rcvrtype, t, tt, ut, v, x, x$1; + rcvrtype = ptrType$1.nil; + t = ptrType$1.nil; + fn = 0; + v = v; + 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") : x.$array[x.$offset + i])); + if (!(m.pkgPath === ptrType$6.nil)) { + $panic(new $String("reflect: " + op + " of unexported method")); + } + iface = $pointerOfStructConversion(v.ptr, ptrType$8); + if (iface.itab === ptrType$9.nil) { + $panic(new $String("reflect: " + op + " of method on nil interface value")); + } + t = m.typ; + prop = m.name.$get(); + } else { + ut = v.typ.uncommonType.uncommon(); + if (ut === ptrType$7.nil || i < 0 || i >= ut.methods.$length) { + $panic(new $String("reflect: internal error: invalid method index")); + } + m$1 = (x$1 = ut.methods, ((i < 0 || i >= x$1.$length) ? $throwRuntimeError("index out of range") : x$1.$array[x$1.$offset + i])); + if (!(m$1.pkgPath === ptrType$6.nil)) { + $panic(new $String("reflect: " + op + " of unexported method")); + } + t = m$1.mtyp; + prop = $internalize($methodSet(jsType(v.typ))[i].prop, $String); + } + rcvr = v.object(); + if (isWrapped(v.typ)) { + rcvr = new (jsType(v.typ))(rcvr); + } + fn = rcvr[$externalize(prop, $String)]; + return [rcvrtype, t, fn]; + }; + valueInterface = function(v, safe) { + var $ptr, _r, safe, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; safe = $f.safe; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = v; + 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", v); /* */ $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)) { + return new (jsType(v.typ))(v.object()); + } + return v.object(); + /* */ } return; } if ($f === undefined) { $f = { $blk: valueInterface }; } $f.$ptr = $ptr; $f._r = _r; $f.safe = safe; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + ifaceE2I = function(t, src, dst) { + var $ptr, dst, src, t; + dst.$set(src); + }; + methodName = function() { + var $ptr; + return "?FIXME?"; + }; + makeMethodValue = function(op, v) { + var $ptr, _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; $ptr = $f.$ptr; _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]; + v = v; + if (((v.flag & 512) >>> 0) === 0) { + $panic(new $String("reflect: internal error: invalid use of makePartialFunc")); + } + _tuple = methodReceiver(op, v, (v.flag >> 0) >> 10 >> 0); + fn[0] = _tuple[2]; + rcvr[0] = v.object(); + if (isWrapped(v.typ)) { + rcvr[0] = new (jsType(v.typ))(rcvr[0]); + } + fv = $makeFunc((function(fn, rcvr) { return function(arguments$1) { + var $ptr, arguments$1; + return fn[0].apply(rcvr[0], $externalize(arguments$1, sliceType$7)); + }; })(fn, rcvr)); + _r = v.Type().common(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ $s = 2; case 2: + return new Value.ptr(_r, fv, (((v.flag & 96) >>> 0) | 19) >>> 0); + /* */ } return; } if ($f === undefined) { $f = { $blk: makeMethodValue }; } $f.$ptr = $ptr; $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 $ptr, _7, t; + t = this; + _7 = t.Kind(); + if ((_7 === (22)) || (_7 === (21)) || (_7 === (18)) || (_7 === (19)) || (_7 === (25)) || (_7 === (17))) { + return true; + } else { + return false; + } + }; + rtype.prototype.pointers = function() { return this.$val.pointers(); }; + rtype.ptr.prototype.Comparable = function() { + var $ptr, _8, _r, _r$1, _r$2, i, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _8 = $f._8; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; i = $f.i; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + t = this; + _8 = t.Kind(); + /* */ if ((_8 === (19)) || (_8 === (23)) || (_8 === (21))) { $s = 2; continue; } + /* */ if (_8 === (17)) { $s = 3; continue; } + /* */ if (_8 === (25)) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if ((_8 === (19)) || (_8 === (23)) || (_8 === (21))) { */ case 2: + return false; + /* } else if (_8 === (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 = 7; case 7: + return _r; + /* } else if (_8 === (25)) { */ case 4: + i = 0; + /* while (true) { */ case 8: + /* if (!(i < t.NumField())) { break; } */ if(!(i < t.NumField())) { $s = 9; continue; } + _r$1 = t.Field(i); /* */ $s = 12; case 12: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$2 = _r$1.Type.Comparable(); /* */ $s = 13; case 13: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + /* */ if (!_r$2) { $s = 10; continue; } + /* */ $s = 11; continue; + /* if (!_r$2) { */ case 10: + return false; + /* } */ case 11: + i = i + (1) >> 0; + /* } */ $s = 8; continue; case 9: + /* } */ case 5: + case 1: + return true; + /* */ } return; } if ($f === undefined) { $f = { $blk: rtype.ptr.prototype.Comparable }; } $f.$ptr = $ptr; $f._8 = _8; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.i = i; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + rtype.prototype.Comparable = function() { return this.$val.Comparable(); }; + uncommonType.ptr.prototype.Method = function(i) { + var $ptr, fl, fn, i, m, mt, p, prop, t, x; + m = new Method.ptr("", "", $ifaceNil, new Value.ptr(ptrType$1.nil, 0, 0), 0); + t = this; + if (t === ptrType$7.nil || i < 0 || i >= t.methods.$length) { + $panic(new $String("reflect: Method index out of range")); + } + p = (x = t.methods, ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i])); + if (!(p.name === ptrType$6.nil)) { + m.Name = p.name.$get(); + } + fl = 19; + if (!(p.pkgPath === ptrType$6.nil)) { + m.PkgPath = p.pkgPath.$get(); + fl = (fl | (32)) >>> 0; + } + mt = p.typ; + m.Type = mt; + prop = $internalize($methodSet(t.jsType)[i].prop, $String); + fn = $makeFunc((function(arguments$1) { + var $ptr, arguments$1, rcvr; + rcvr = (0 >= arguments$1.$length ? $throwRuntimeError("index out of range") : arguments$1.$array[arguments$1.$offset + 0]); + return rcvr[$externalize(prop, $String)].apply(rcvr, $externalize($subslice(arguments$1, 1), sliceType$7)); + })); + m.Func = new Value.ptr(mt, fn, fl); + m.Index = i; + return m; + }; + uncommonType.prototype.Method = function(i) { return this.$val.Method(i); }; + Value.ptr.prototype.object = function() { + var $ptr, _9, 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: + _9 = v.typ.Kind(); + if ((_9 === (11)) || (_9 === (6))) { + val = new (jsType(v.typ))(val.$high, val.$low); + } else if ((_9 === (15)) || (_9 === (16))) { + val = new (jsType(v.typ))(val.$real, val.$imag); + } else if (_9 === (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.call = function(op, in$1) { + var $ptr, _10, _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; $ptr = $f.$ptr; _10 = $f._10; _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 = v.typ; + fn = 0; + rcvr = null; + if (!((((v.flag & 512) >>> 0) === 0))) { + _tuple = methodReceiver(op, v, (v.flag >> 0) >> 10 >> 0); + t = _tuple[1]; + fn = _tuple[2]; + rcvr = v.object(); + if (isWrapped(v.typ)) { + rcvr = new (jsType(v.typ))(rcvr); + } + } else { + fn = v.object(); + rcvr = undefined; + } + if (fn === 0) { + $panic(new $String("reflect.Value.Call: call of nil function")); + } + isSlice = op === "CallSlice"; + n = t.NumIn(); + if (isSlice) { + if (!t.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.IsVariadic()) { + n = n - (1) >> 0; + } + if (in$1.$length < n) { + $panic(new $String("reflect: Call with too few input arguments")); + } + if (!t.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") : _ref.$array[_ref.$offset + _i]); + if (x.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 = ((i < 0 || i >= in$1.$length) ? $throwRuntimeError("index out of range") : in$1.$array[in$1.$offset + i]).Type(); + _tmp$1 = t.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.IsVariadic()) { $s = 8; continue; } + /* */ $s = 9; continue; + /* if (!isSlice && t.IsVariadic()) { */ case 8: + m = in$1.$length - n >> 0; + _r$3 = MakeSlice(t.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.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") : in$1.$array[in$1.$offset + x$1])); + xt$1 = x$2.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 = slice.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 = _r$8.Set(x$2); /* */ $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$8, (n + 1 >> 0)); + $copySlice($subslice(in$1, 0, n), origIn); + ((n < 0 || n >= in$1.$length) ? $throwRuntimeError("index out of range") : in$1.$array[in$1.$offset + n] = slice); + /* } */ case 9: + nin = in$1.$length; + if (!((nin === t.NumIn()))) { + $panic(new $String("reflect.Value.Call: wrong argument count")); + } + nout = t.NumOut(); + argsArray = new ($global.Array)(t.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") : _ref$1.$array[_ref$1.$offset + _i$1]); + _arg = t.In(i$2); + _r$9 = t.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 = arg.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 = _r$10.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$2([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; + _10 = nout; + /* */ if (_10 === (0)) { $s = 29; continue; } + /* */ if (_10 === (1)) { $s = 30; continue; } + /* */ $s = 31; continue; + /* if (_10 === (0)) { */ case 29: + return sliceType$8.nil; + /* } else if (_10 === (1)) { */ case 30: + _r$14 = makeValue(t.Out(0), wrapJsObject(t.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 = 34; case 34: + return new sliceType$8([$clone(_r$14, Value)]); + /* } else { */ case 31: + ret = $makeSlice(sliceType$8, nout); + _ref$2 = ret; + _i$2 = 0; + /* while (true) { */ case 35: + /* if (!(_i$2 < _ref$2.$length)) { break; } */ if(!(_i$2 < _ref$2.$length)) { $s = 36; continue; } + i$3 = _i$2; + _r$15 = makeValue(t.Out(i$3), wrapJsObject(t.Out(i$3), results[i$3]), 0); /* */ $s = 37; case 37: 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") : ret.$array[ret.$offset + i$3] = _r$15); + _i$2++; + /* } */ $s = 35; continue; case 36: + return ret; + /* } */ case 32: + case 28: + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.call }; } $f.$ptr = $ptr; $f._10 = _10; $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 $ptr, _11, k, v; + v = this; + k = new flag(v.flag).kind(); + _11 = k; + if (_11 === (17)) { + return v.typ.Len(); + } else if ((_11 === (18)) || (_11 === (23))) { + return $parseInt(v.object().$capacity) >> 0; + } + $panic(new ValueError.ptr("reflect.Value.Cap", k)); + }; + Value.prototype.Cap = function() { return this.$val.Cap(); }; + wrapJsObject = function(typ, val) { + var $ptr, typ, val; + if ($interfaceIsEqual(typ, jsObjectPtr)) { + return new (jsType(jsObjectPtr))(val); + } + return val; + }; + unwrapJsObject = function(typ, val) { + var $ptr, typ, val; + if ($interfaceIsEqual(typ, jsObjectPtr)) { + return val.object; + } + return val; + }; + Value.ptr.prototype.Elem = function() { + var $ptr, _12, _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; $ptr = $f.$ptr; _12 = $f._12; _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(); + _12 = k; + /* */ if (_12 === (20)) { $s = 2; continue; } + /* */ if (_12 === (22)) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (_12 === (20)) { */ case 2: + val = v.object(); + if (val === $ifaceNil) { + return new Value.ptr(ptrType$1.nil, 0, 0); + } + typ = reflectType(val.constructor); + _r = makeValue(typ, val.$val, (v.flag & 96) >>> 0); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ $s = 7; case 7: + return _r; + /* } else if (_12 === (22)) { */ case 3: + if (v.IsNil()) { + return new Value.ptr(ptrType$1.nil, 0, 0); + } + val$1 = v.object(); + tt = v.typ.kindType; + fl = (((((v.flag & 96) >>> 0) | 128) >>> 0) | 256) >>> 0; + fl = (fl | ((tt.elem.Kind() >>> 0))) >>> 0; + 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; case -1: } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Elem }; } $f.$ptr = $ptr; $f._12 = _12; $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 $ptr, _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; $ptr = $f.$ptr; _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; + new flag(v.flag).mustBe(25); + tt = v.typ.kindType; + if (i < 0 || i >= tt.fields.$length) { + $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") : x.$array[x.$offset + i])); + typ[0] = field.typ; + fl = (((v.flag & 416) >>> 0) | (typ[0].Kind() >>> 0)) >>> 0; + if (!(field.pkgPath === ptrType$6.nil)) { + if (field.name === ptrType$6.nil) { + fl = (fl | (64)) >>> 0; + } else { + fl = (fl | (32)) >>> 0; + } + } + tag = (x$1 = tt.fields, ((i < 0 || i >= x$1.$length) ? $throwRuntimeError("index out of range") : x$1.$array[x$1.$offset + i])).tag; + /* */ if (!(tag === ptrType$6.nil) && !((i === 0))) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (!(tag === ptrType$6.nil) && !((i === 0))) { */ case 1: + jsTag[0] = getJsTag(tag.$get()); + /* */ if (!(jsTag[0] === "")) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (!(jsTag[0] === "")) { */ case 3: + /* while (true) { */ case 5: + o = [o]; + _r = v.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] = v.object().object; + return new Value.ptr(typ[0], new (jsType(PtrTo(typ[0])))((function(jsTag, o, prop, s, typ) { return function() { + var $ptr; + 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 $ptr, 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 = v.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: + return new Value.ptr(typ[0], new (jsType(PtrTo(typ[0])))((function(jsTag, prop, s, typ) { return function() { + var $ptr; + return wrapJsObject(typ[0], s[0][$externalize(prop[0], $String)]); + }; })(jsTag, prop, s, typ), (function(jsTag, prop, s, typ) { return function(x$2) { + var $ptr, 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 = 16; case 16: + return _r$2; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Field }; } $f.$ptr = $ptr; $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 $ptr, _tuple, i, name, 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 = tag.substring(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 = tag.substring(0, i); + tag = tag.substring((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 = tag.substring(0, (i + 1 >> 0)); + tag = tag.substring((i + 1 >> 0)); + if (name === "js") { + _tuple = strconv.Unquote(qvalue); + value = _tuple[0]; + return value; + } + } + return ""; + }; + Value.ptr.prototype.Index = function(i) { + var $ptr, _13, _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; $ptr = $f.$ptr; _13 = $f._13; _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(); + _13 = k; + /* */ if (_13 === (17)) { $s = 2; continue; } + /* */ if (_13 === (23)) { $s = 3; continue; } + /* */ if (_13 === (24)) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (_13 === (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$1[0] = tt.elem; + fl = (v.flag & 480) >>> 0; + fl = (fl | ((typ$1[0].Kind() >>> 0))) >>> 0; + a$1[0] = v.ptr; + /* */ if (!((((fl & 128) >>> 0) === 0)) && !((typ$1[0].Kind() === 17)) && !((typ$1[0].Kind() === 25))) { $s = 7; continue; } + /* */ $s = 8; continue; + /* if (!((((fl & 128) >>> 0) === 0)) && !((typ$1[0].Kind() === 17)) && !((typ$1[0].Kind() === 25))) { */ case 7: + return new Value.ptr(typ$1[0], new (jsType(PtrTo(typ$1[0])))((function(a, a$1, c, i, typ, typ$1) { return function() { + var $ptr; + 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 $ptr, x; + a$1[0][i[0]] = unwrapJsObject(typ$1[0], x); + }; })(a, a$1, c, i, typ, typ$1)), fl); + /* } */ case 8: + _r = makeValue(typ$1[0], wrapJsObject(typ$1[0], a$1[0][i[0]]), fl); /* */ $s = 9; case 9: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ $s = 10; case 10: + return _r; + /* } else if (_13 === (23)) { */ case 3: + s = v.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[0] = tt$1.elem; + fl$1 = (384 | ((v.flag & 96) >>> 0)) >>> 0; + fl$1 = (fl$1 | ((typ[0].Kind() >>> 0))) >>> 0; + i[0] = i[0] + (($parseInt(s.$offset) >> 0)) >> 0; + a[0] = s.$array; + /* */ if (!((((fl$1 & 128) >>> 0) === 0)) && !((typ[0].Kind() === 17)) && !((typ[0].Kind() === 25))) { $s = 11; continue; } + /* */ $s = 12; continue; + /* if (!((((fl$1 & 128) >>> 0) === 0)) && !((typ[0].Kind() === 17)) && !((typ[0].Kind() === 25))) { */ case 11: + return new Value.ptr(typ[0], new (jsType(PtrTo(typ[0])))((function(a, a$1, c, i, typ, typ$1) { return function() { + var $ptr; + 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 $ptr, x; + a[0][i[0]] = unwrapJsObject(typ[0], x); + }; })(a, a$1, c, i, typ, typ$1)), fl$1); + /* } */ case 12: + _r$1 = makeValue(typ[0], wrapJsObject(typ[0], a[0][i[0]]), fl$1); /* */ $s = 13; case 13: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + /* */ $s = 14; case 14: + return _r$1; + /* } else if (_13 === (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 = (((v.flag & 96) >>> 0) | 8) >>> 0; + c[0] = str.charCodeAt(i[0]); + return new Value.ptr(uint8Type, (c.$ptr || (c.$ptr = new ptrType$5(function() { return this.$target[0]; }, function($v) { this.$target[0] = $v; }, c))), (fl$2 | 128) >>> 0); + /* } else { */ case 5: + $panic(new ValueError.ptr("reflect.Value.Index", k)); + /* } */ case 6: + case 1: + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Index }; } $f.$ptr = $ptr; $f._13 = _13; $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 $ptr, 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 $ptr, _14, k, v; + v = this; + k = new flag(v.flag).kind(); + _14 = k; + if ((_14 === (22)) || (_14 === (23))) { + return v.object() === jsType(v.typ).nil; + } else if (_14 === (18)) { + return v.object() === $chanNil; + } else if (_14 === (19)) { + return v.object() === $throwNilPointerError; + } else if (_14 === (21)) { + return v.object() === false; + } else if (_14 === (20)) { + return v.object() === $ifaceNil; + } else { + $panic(new ValueError.ptr("reflect.Value.IsNil", k)); + } + }; + Value.prototype.IsNil = function() { return this.$val.IsNil(); }; + Value.ptr.prototype.Len = function() { + var $ptr, _15, k, v; + v = this; + k = new flag(v.flag).kind(); + _15 = k; + if ((_15 === (17)) || (_15 === (24))) { + return $parseInt(v.object().length); + } else if (_15 === (23)) { + return $parseInt(v.object().$length) >> 0; + } else if (_15 === (18)) { + return $parseInt(v.object().$buffer.length) >> 0; + } else if (_15 === (21)) { + return $parseInt($keys(v.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 $ptr, _16, k, v; + v = this; + k = new flag(v.flag).kind(); + _16 = k; + if ((_16 === (18)) || (_16 === (21)) || (_16 === (22)) || (_16 === (26))) { + if (v.IsNil()) { + return 0; + } + return v.object(); + } else if (_16 === (19)) { + if (v.IsNil()) { + return 0; + } + return 1; + } else if (_16 === (23)) { + if (v.IsNil()) { + return 0; + } + return v.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 $ptr, _17, _r, _r$1, v, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _17 = $f._17; _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: + x = x; + v = this; + new flag(v.flag).mustBeAssignable(); + new flag(x.flag).mustBeExported(); + _r = x.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: + _17 = v.typ.Kind(); + /* */ if (_17 === (17)) { $s = 5; continue; } + /* */ if (_17 === (20)) { $s = 6; continue; } + /* */ if (_17 === (25)) { $s = 7; continue; } + /* */ $s = 8; continue; + /* if (_17 === (17)) { */ case 5: + jsType(v.typ).copy(v.ptr, x.ptr); + $s = 9; continue; + /* } else if (_17 === (20)) { */ case 6: + _r$1 = valueInterface(x, 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 (_17 === (25)) { */ case 7: + copyStruct(v.ptr, x.ptr, v.typ); + $s = 9; continue; + /* } else { */ case 8: + v.ptr.$set(x.object()); + /* } */ case 9: + case 4: + return; + /* } */ case 3: + v.ptr = x.ptr; + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Set }; } $f.$ptr = $ptr; $f._17 = _17; $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 $ptr, _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; $ptr = $f.$ptr; _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; case -1: } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.SetBytes }; } $f.$ptr = $ptr; $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 $ptr, 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 $ptr, 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 $ptr, _18, _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; $ptr = $f.$ptr; _18 = $f._18; _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(); + _18 = kind; + /* */ if (_18 === (17)) { $s = 2; continue; } + /* */ if (_18 === (23)) { $s = 3; continue; } + /* */ if (_18 === (24)) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (_18 === (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))(v.object()); + $s = 6; continue; + /* } else if (_18 === (23)) { */ case 3: + typ = v.typ; + s = v.object(); + cap = $parseInt(s.$capacity) >> 0; + $s = 6; continue; + /* } else if (_18 === (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(str.substring(i, j))); /* */ $s = 7; case 7: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ $s = 8; case 8: + 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), (v.flag & 96) >>> 0); /* */ $s = 9; case 9: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + /* */ $s = 10; case 10: + return _r$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Slice }; } $f.$ptr = $ptr; $f._18 = _18; $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 $ptr, _19, _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; $ptr = $f.$ptr; _19 = $f._19; _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(); + _19 = kind; + if (_19 === (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))(v.object()); + } else if (_19 === (23)) { + typ = v.typ; + s = v.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), (v.flag & 96) >>> 0); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ $s = 2; case 2: + return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Slice3 }; } $f.$ptr = $ptr; $f._19 = _19; $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 $ptr, v; + v = this; + new flag(v.flag).mustBe(18); + new flag(v.flag).mustBeExported(); + $close(v.object()); + }; + Value.prototype.Close = function() { return this.$val.Close(); }; + chanrecv = function(t, ch, nb, val) { + var $ptr, _r, _tmp, _tmp$1, _tmp$2, _tmp$3, ch, comms, nb, received, recvRes, selectRes, selected, t, val, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _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; t = $f.t; val = $f.val; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + selected = false; + received = false; + comms = new sliceType$9([new sliceType$7([ch])]); + if (nb) { + comms = $append(comms, new sliceType$7([])); + } + _r = selectHelper(new sliceType$2([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; + return [selected, received]; + } + recvRes = selectRes[1]; + val.$set(recvRes[0]); + _tmp$2 = true; + _tmp$3 = !!(recvRes[1]); + selected = _tmp$2; + received = _tmp$3; + return [selected, received]; + /* */ } return; } if ($f === undefined) { $f = { $blk: chanrecv }; } $f.$ptr = $ptr; $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.t = t; $f.val = val; $f.$s = $s; $f.$r = $r; return $f; + }; + chansend = function(t, ch, val, nb) { + var $ptr, _r, ch, comms, nb, selectRes, t, val, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; ch = $f.ch; comms = $f.comms; nb = $f.nb; selectRes = $f.selectRes; t = $f.t; val = $f.val; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + comms = new sliceType$9([new sliceType$7([ch, val.$get()])]); + if (nb) { + comms = $append(comms, new sliceType$7([])); + } + _r = selectHelper(new sliceType$2([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)) { + return false; + } + return true; + /* */ } return; } if ($f === undefined) { $f = { $blk: chansend }; } $f.$ptr = $ptr; $f._r = _r; $f.ch = ch; $f.comms = comms; $f.nb = nb; $f.selectRes = selectRes; $f.t = t; $f.val = val; $f.$s = $s; $f.$r = $r; return $f; + }; + Kind.prototype.String = function() { + var $ptr, k; + k = this.$val; + if ((k >> 0) < kindNames.$length) { + return ((k < 0 || k >= kindNames.$length) ? $throwRuntimeError("index out of range") : kindNames.$array[kindNames.$offset + k]); + } + return "kind" + strconv.Itoa((k >> 0)); + }; + $ptrType(Kind).prototype.String = function() { return new Kind(this.$get()).String(); }; + uncommonType.ptr.prototype.uncommon = function() { + var $ptr, t; + t = this; + return t; + }; + uncommonType.prototype.uncommon = function() { return this.$val.uncommon(); }; + uncommonType.ptr.prototype.PkgPath = function() { + var $ptr, t; + t = this; + if (t === ptrType$7.nil || t.pkgPath === ptrType$6.nil) { + return ""; + } + return t.pkgPath.$get(); + }; + uncommonType.prototype.PkgPath = function() { return this.$val.PkgPath(); }; + uncommonType.ptr.prototype.Name = function() { + var $ptr, t; + t = this; + if (t === ptrType$7.nil || t.name === ptrType$6.nil) { + return ""; + } + return t.name.$get(); + }; + uncommonType.prototype.Name = function() { return this.$val.Name(); }; + rtype.ptr.prototype.String = function() { + var $ptr, t; + t = this; + return t.string.$get(); + }; + rtype.prototype.String = function() { return this.$val.String(); }; + rtype.ptr.prototype.Size = function() { + var $ptr, t; + t = this; + return t.size; + }; + rtype.prototype.Size = function() { return this.$val.Size(); }; + rtype.ptr.prototype.Bits = function() { + var $ptr, 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 $ptr, t; + t = this; + return (t.align >> 0); + }; + rtype.prototype.Align = function() { return this.$val.Align(); }; + rtype.ptr.prototype.FieldAlign = function() { + var $ptr, t; + t = this; + return (t.fieldAlign >> 0); + }; + rtype.prototype.FieldAlign = function() { return this.$val.FieldAlign(); }; + rtype.ptr.prototype.Kind = function() { + var $ptr, t; + t = this; + return (((t.kind & 31) >>> 0) >>> 0); + }; + rtype.prototype.Kind = function() { return this.$val.Kind(); }; + rtype.ptr.prototype.common = function() { + var $ptr, t; + t = this; + return t; + }; + rtype.prototype.common = function() { return this.$val.common(); }; + uncommonType.ptr.prototype.NumMethod = function() { + var $ptr, t; + t = this; + if (t === ptrType$7.nil) { + return 0; + } + return t.methods.$length; + }; + uncommonType.prototype.NumMethod = function() { return this.$val.NumMethod(); }; + uncommonType.ptr.prototype.MethodByName = function(name) { + var $ptr, _i, _ref, _tmp, _tmp$1, i, m, name, 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$7.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") : x.$array[x.$offset + i])); + if (!(p.name === ptrType$6.nil) && p.name.$get() === name) { + _tmp = $clone(t.Method(i), Method); + _tmp$1 = true; + Method.copy(m, _tmp); + ok = _tmp$1; + return [m, ok]; + } + _i++; + } + return [m, ok]; + }; + uncommonType.prototype.MethodByName = function(name) { return this.$val.MethodByName(name); }; + rtype.ptr.prototype.NumMethod = function() { + var $ptr, t, tt; + t = this; + if (t.Kind() === 20) { + tt = t.kindType; + return tt.NumMethod(); + } + return t.uncommonType.NumMethod(); + }; + rtype.prototype.NumMethod = function() { return this.$val.NumMethod(); }; + rtype.ptr.prototype.Method = function(i) { + var $ptr, i, m, t, tt; + 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)); + return m; + } + Method.copy(m, t.uncommonType.Method(i)); + return m; + }; + rtype.prototype.Method = function(i) { return this.$val.Method(i); }; + rtype.ptr.prototype.MethodByName = function(name) { + var $ptr, _tuple, _tuple$1, m, name, ok, t, tt; + 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); + Method.copy(m, _tuple[0]); + ok = _tuple[1]; + return [m, ok]; + } + _tuple$1 = t.uncommonType.MethodByName(name); + Method.copy(m, _tuple$1[0]); + ok = _tuple$1[1]; + return [m, ok]; + }; + rtype.prototype.MethodByName = function(name) { return this.$val.MethodByName(name); }; + rtype.ptr.prototype.PkgPath = function() { + var $ptr, t; + t = this; + return t.uncommonType.PkgPath(); + }; + rtype.prototype.PkgPath = function() { return this.$val.PkgPath(); }; + rtype.ptr.prototype.Name = function() { + var $ptr, t; + t = this; + return t.uncommonType.Name(); + }; + rtype.prototype.Name = function() { return this.$val.Name(); }; + rtype.ptr.prototype.ChanDir = function() { + var $ptr, 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 $ptr, t, tt; + t = this; + if (!((t.Kind() === 19))) { + $panic(new $String("reflect: IsVariadic of non-func type")); + } + tt = t.kindType; + return tt.dotdotdot; + }; + rtype.prototype.IsVariadic = function() { return this.$val.IsVariadic(); }; + rtype.ptr.prototype.Elem = function() { + var $ptr, _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 $ptr, _r, i, t, tt, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; i = $f.i; 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: Field of non-struct type")); + } + tt = t.kindType; + _r = tt.Field(i); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ $s = 2; case 2: + return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: rtype.ptr.prototype.Field }; } $f.$ptr = $ptr; $f._r = _r; $f.i = i; $f.t = t; $f.tt = tt; $f.$s = $s; $f.$r = $r; return $f; + }; + rtype.prototype.Field = function(i) { return this.$val.Field(i); }; + rtype.ptr.prototype.FieldByIndex = function(index) { + var $ptr, _r, index, t, tt, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _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 = 2; case 2: + return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: rtype.ptr.prototype.FieldByIndex }; } $f.$ptr = $ptr; $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) { + var $ptr, _r, name, t, tt, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; name = $f.name; 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); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ $s = 2; case 2: + return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: rtype.ptr.prototype.FieldByName }; } $f.$ptr = $ptr; $f._r = _r; $f.name = name; $f.t = t; $f.tt = tt; $f.$s = $s; $f.$r = $r; return $f; + }; + rtype.prototype.FieldByName = function(name) { return this.$val.FieldByName(name); }; + rtype.ptr.prototype.FieldByNameFunc = function(match) { + var $ptr, _r, match, t, tt, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _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 = 2; case 2: + return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: rtype.ptr.prototype.FieldByNameFunc }; } $f.$ptr = $ptr; $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 $ptr, 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$2, ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]))); + }; + rtype.prototype.In = function(i) { return this.$val.In(i); }; + rtype.ptr.prototype.Key = function() { + var $ptr, 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 $ptr, 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 $ptr, 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 $ptr, t, tt; + t = this; + if (!((t.Kind() === 19))) { + $panic(new $String("reflect: NumIn of non-func type")); + } + tt = t.kindType; + return tt.in$2.$length; + }; + rtype.prototype.NumIn = function() { return this.$val.NumIn(); }; + rtype.ptr.prototype.NumOut = function() { + var $ptr, 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 $ptr, 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") : x.$array[x.$offset + i]))); + }; + rtype.prototype.Out = function(i) { return this.$val.Out(i); }; + ChanDir.prototype.String = function() { + var $ptr, _2, d; + d = this.$val; + _2 = d; + if (_2 === (2)) { + return "chan<-"; + } else if (_2 === (1)) { + return "<-chan"; + } else if (_2 === (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 $ptr, i, m, p, 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") : x.$array[x.$offset + i])); + m.Name = p.name.$get(); + if (!(p.pkgPath === ptrType$6.nil)) { + m.PkgPath = p.pkgPath.$get(); + } + m.Type = toType(p.typ); + m.Index = i; + return m; + }; + interfaceType.prototype.Method = function(i) { return this.$val.Method(i); }; + interfaceType.ptr.prototype.NumMethod = function() { + var $ptr, t; + t = this; + return t.methods.$length; + }; + interfaceType.prototype.NumMethod = function() { return this.$val.NumMethod(); }; + interfaceType.ptr.prototype.MethodByName = function(name) { + var $ptr, _i, _ref, _tmp, _tmp$1, i, m, name, 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$11.nil) { + return [m, ok]; + } + p = ptrType$12.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") : x.$array[x.$offset + i])); + if (p.name.$get() === name) { + _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) { return this.$val.MethodByName(name); }; + StructTag.prototype.Get = function(key) { + var $ptr, _tuple, err, i, key, name, qvalue, tag, value; + 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 = tag.substring(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 = tag.substring(0, i); + tag = tag.substring((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 = tag.substring(0, (i + 1 >> 0)); + tag = tag.substring((i + 1 >> 0)); + if (key === name) { + _tuple = strconv.Unquote(qvalue); + value = _tuple[0]; + err = _tuple[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + break; + } + return value; + } + } + return ""; + }; + $ptrType(StructTag).prototype.Get = function(key) { return new StructTag(this.$get()).Get(key); }; + structType.ptr.prototype.Field = function(i) { + var $ptr, _r, _r$1, _r$2, f, i, p, t, t$1, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; f = $f.f; i = $f.i; p = $f.p; t = $f.t; t$1 = $f.t$1; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = new StructField.ptr("", "", $ifaceNil, "", 0, sliceType$11.nil, false); + t = this; + if (i < 0 || i >= t.fields.$length) { + return f; + } + p = (x = t.fields, ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i])); + f.Type = toType(p.typ); + /* */ if (!(p.name === ptrType$6.nil)) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (!(p.name === ptrType$6.nil)) { */ case 1: + f.Name = p.name.$get(); + $s = 3; continue; + /* } else { */ case 2: + t$1 = f.Type; + _r = t$1.Kind(); /* */ $s = 6; case 6: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ if (_r === 22) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (_r === 22) { */ case 4: + _r$1 = t$1.Elem(); /* */ $s = 7; case 7: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + t$1 = _r$1; + /* } */ case 5: + _r$2 = t$1.Name(); /* */ $s = 8; case 8: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + f.Name = _r$2; + f.Anonymous = true; + /* } */ case 3: + if (!(p.pkgPath === ptrType$6.nil)) { + f.PkgPath = p.pkgPath.$get(); + } + if (!(p.tag === ptrType$6.nil)) { + f.Tag = p.tag.$get(); + } + f.Offset = p.offset; + f.Index = new sliceType$11([i]); + return f; + /* */ } return; } if ($f === undefined) { $f = { $blk: structType.ptr.prototype.Field }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f.f = f; $f.i = i; $f.p = p; $f.t = t; $f.t$1 = t$1; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + structType.prototype.Field = function(i) { return this.$val.Field(i); }; + structType.ptr.prototype.FieldByIndex = function(index) { + var $ptr, _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; $ptr = $f.$ptr; _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$11.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") : _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: + return f; + /* */ } return; } if ($f === undefined) { $f = { $blk: structType.ptr.prototype.FieldByIndex }; } $f.$ptr = $ptr; $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 $ptr, _entry, _entry$1, _entry$2, _entry$3, _i, _i$1, _key, _key$1, _key$2, _key$3, _r, _r$1, _r$2, _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; $ptr = $f.$ptr; _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; _r$2 = $f._r$2; _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$11.nil, false); + ok = false; + t = this; + current = new sliceType$12([]); + next = new sliceType$12([new fieldScan.ptr(t, sliceType$11.nil)]); + nextCount = false; + visited = $makeMap(ptrType$13.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") : _ref.$array[_ref.$offset + _i]), fieldScan); + t$1 = scan.typ; + /* */ if ((_entry = visited[ptrType$13.keyFor(t$1)], _entry !== undefined ? _entry.v : false)) { $s = 5; continue; } + /* */ $s = 6; continue; + /* if ((_entry = visited[ptrType$13.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$13.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") : x.$array[x.$offset + i])); + fname = ""; + ntyp = ptrType$1.nil; + /* */ if (!(f.name === ptrType$6.nil)) { $s = 9; continue; } + /* */ $s = 10; continue; + /* if (!(f.name === ptrType$6.nil)) { */ case 9: + fname = f.name.$get(); + $s = 11; continue; + /* } else { */ case 10: + ntyp = f.typ; + /* */ if (ntyp.Kind() === 22) { $s = 12; continue; } + /* */ $s = 13; continue; + /* if (ntyp.Kind() === 22) { */ case 12: + _r = ntyp.Elem().common(); /* */ $s = 14; case 14: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + ntyp = _r; + /* } */ case 13: + fname = ntyp.Name(); + /* } */ case 11: + _r$1 = match(fname); /* */ $s = 17; case 17: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + /* */ if (_r$1) { $s = 15; continue; } + /* */ $s = 16; continue; + /* if (_r$1) { */ case 15: + if ((_entry$1 = count[ptrType$13.keyFor(t$1)], _entry$1 !== undefined ? _entry$1.v : 0) > 1 || ok) { + _tmp$2 = new StructField.ptr("", "", $ifaceNil, "", 0, sliceType$11.nil, false); + _tmp$3 = false; + StructField.copy(result, _tmp$2); + ok = _tmp$3; + return [result, ok]; + } + _r$2 = t$1.Field(i); /* */ $s = 18; case 18: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + StructField.copy(result, _r$2); + result.Index = sliceType$11.nil; + result.Index = $appendSlice(result.Index, scan.index); + result.Index = $append(result.Index, i); + ok = true; + _i$1++; + /* continue; */ $s = 7; continue; + /* } */ case 16: + if (ok || ntyp === ptrType$1.nil || !((ntyp.Kind() === 25))) { + _i$1++; + /* continue; */ $s = 7; continue; + } + styp = ntyp.kindType; + if ((_entry$2 = nextCount[ptrType$13.keyFor(styp)], _entry$2 !== undefined ? _entry$2.v : 0) > 0) { + _key$1 = styp; (nextCount || $throwRuntimeError("assignment to entry in nil map"))[ptrType$13.keyFor(_key$1)] = { k: _key$1, v: 2 }; + _i$1++; + /* continue; */ $s = 7; continue; + } + if (nextCount === false) { + nextCount = $makeMap(ptrType$13.keyFor, []); + } + _key$2 = styp; (nextCount || $throwRuntimeError("assignment to entry in nil map"))[ptrType$13.keyFor(_key$2)] = { k: _key$2, v: 1 }; + if ((_entry$3 = count[ptrType$13.keyFor(t$1)], _entry$3 !== undefined ? _entry$3.v : 0) > 1) { + _key$3 = styp; (nextCount || $throwRuntimeError("assignment to entry in nil map"))[ptrType$13.keyFor(_key$3)] = { k: _key$3, v: 2 }; + } + index = sliceType$11.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: + return [result, ok]; + /* */ } return; } if ($f === undefined) { $f = { $blk: structType.ptr.prototype.FieldByNameFunc }; } $f.$ptr = $ptr; $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._r$2 = _r$2; $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) { + var $ptr, _i, _r, _r$1, _ref, _tmp, _tmp$1, _tuple, f, hasAnon, i, name, present, t, tf, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _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; f = $f.f; hasAnon = $f.hasAnon; i = $f.i; name = $f.name; 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 = [name]; + f = new StructField.ptr("", "", $ifaceNil, "", 0, sliceType$11.nil, false); + present = false; + t = this; + hasAnon = false; + /* */ if (!(name[0] === "")) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (!(name[0] === "")) { */ case 1: + _ref = t.fields; + _i = 0; + /* while (true) { */ case 3: + /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 4; continue; } + i = _i; + tf = (x = t.fields, ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i])); + /* */ if (tf.name === ptrType$6.nil) { $s = 5; continue; } + /* */ $s = 6; continue; + /* if (tf.name === ptrType$6.nil) { */ case 5: + hasAnon = true; + _i++; + /* continue; */ $s = 3; continue; + /* } */ case 6: + /* */ if (tf.name.$get() === name[0]) { $s = 7; continue; } + /* */ $s = 8; continue; + /* if (tf.name.$get() === name[0]) { */ case 7: + _r = t.Field(i); /* */ $s = 9; case 9: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tmp = $clone(_r, StructField); + _tmp$1 = true; + StructField.copy(f, _tmp); + present = _tmp$1; + /* */ $s = 10; case 10: + return [f, present]; + /* } */ case 8: + _i++; + /* } */ $s = 3; continue; case 4: + /* } */ case 2: + if (!hasAnon) { + return [f, present]; + } + _r$1 = t.FieldByNameFunc((function(name) { return function(s) { + var $ptr, s; + return s === name[0]; + }; })(name)); /* */ $s = 11; case 11: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _tuple = _r$1; + StructField.copy(f, _tuple[0]); + present = _tuple[1]; + /* */ $s = 12; case 12: + return [f, present]; + /* */ } return; } if ($f === undefined) { $f = { $blk: structType.ptr.prototype.FieldByName }; } $f.$ptr = $ptr; $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.f = f; $f.hasAnon = hasAnon; $f.i = i; $f.name = name; $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) { return this.$val.FieldByName(name); }; + PtrTo = function(t) { + var $ptr, t; + return $assertType(t, ptrType$1).ptrTo(); + }; + $pkg.PtrTo = PtrTo; + rtype.ptr.prototype.Implements = function(u) { + var $ptr, _r, t, u, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _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: + return implements$1($assertType(u, ptrType$1), t); + /* */ } return; } if ($f === undefined) { $f = { $blk: rtype.ptr.prototype.Implements }; } $f.$ptr = $ptr; $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 $ptr, t, u, uu; + t = this; + if ($interfaceIsEqual(u, $ifaceNil)) { + $panic(new $String("reflect: nil type passed to Type.AssignableTo")); + } + uu = $assertType(u, ptrType$1); + return directlyAssignable(uu, t) || implements$1(uu, t); + }; + rtype.prototype.AssignableTo = function(u) { return this.$val.AssignableTo(u); }; + rtype.ptr.prototype.ConvertibleTo = function(u) { + var $ptr, _r, t, u, uu, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _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 = 2; case 2: + return !(_r === $throwNilPointerError); + /* */ } return; } if ($f === undefined) { $f = { $blk: rtype.ptr.prototype.ConvertibleTo }; } $f.$ptr = $ptr; $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 $ptr, T, V, i, i$1, j, j$1, t, tm, tm$1, v, v$1, vm, vm$1, x, x$1, x$2, x$3; + 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") : x.$array[x.$offset + i])); + vm = (x$1 = v.methods, ((j < 0 || j >= x$1.$length) ? $throwRuntimeError("index out of range") : x$1.$array[x$1.$offset + j])); + if (vm.name.$get() === tm.name.$get() && vm.pkgPath === tm.pkgPath && vm.typ === tm.typ) { + i = i + (1) >> 0; + if (i >= t.methods.$length) { + return true; + } + } + j = j + (1) >> 0; + } + return false; + } + v$1 = V.uncommonType.uncommon(); + if (v$1 === ptrType$7.nil) { + return false; + } + i$1 = 0; + j$1 = 0; + while (true) { + if (!(j$1 < v$1.methods.$length)) { break; } + tm$1 = (x$2 = t.methods, ((i$1 < 0 || i$1 >= x$2.$length) ? $throwRuntimeError("index out of range") : x$2.$array[x$2.$offset + i$1])); + vm$1 = (x$3 = v$1.methods, ((j$1 < 0 || j$1 >= x$3.$length) ? $throwRuntimeError("index out of range") : x$3.$array[x$3.$offset + j$1])); + if (vm$1.name.$get() === tm$1.name.$get() && vm$1.pkgPath === tm$1.pkgPath && vm$1.mtyp === tm$1.typ) { + 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 $ptr, T, V; + if (T === V) { + return true; + } + if (!(T.Name() === "") && !(V.Name() === "") || !((T.Kind() === V.Kind()))) { + return false; + } + return haveIdenticalUnderlyingType(T, V); + }; + haveIdenticalUnderlyingType = function(T, V) { + var $ptr, T, V, _3, _i, _i$1, _i$2, _ref, _ref$1, _ref$2, i, i$1, i$2, kind, t, t$1, t$2, tf, typ, typ$1, v, v$1, v$2, vf, x, x$1, x$2, x$3; + if (T === V) { + return true; + } + kind = T.Kind(); + if (!((kind === V.Kind()))) { + return false; + } + if (1 <= kind && kind <= 16 || (kind === 24) || (kind === 26)) { + return true; + } + _3 = kind; + if (_3 === (17)) { + return $interfaceIsEqual(T.Elem(), V.Elem()) && (T.Len() === V.Len()); + } else if (_3 === (18)) { + if ((V.ChanDir() === 3) && $interfaceIsEqual(T.Elem(), V.Elem())) { + return true; + } + return (V.ChanDir() === T.ChanDir()) && $interfaceIsEqual(T.Elem(), V.Elem()); + } else if (_3 === (19)) { + t = T.kindType; + v = V.kindType; + if (!(t.dotdotdot === v.dotdotdot) || !((t.in$2.$length === v.in$2.$length)) || !((t.out.$length === v.out.$length))) { + return false; + } + _ref = t.in$2; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + typ = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]); + if (!(typ === (x = v.in$2, ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i])))) { + return false; + } + _i++; + } + _ref$1 = t.out; + _i$1 = 0; + while (true) { + if (!(_i$1 < _ref$1.$length)) { break; } + i$1 = _i$1; + typ$1 = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i$1]); + if (!(typ$1 === (x$1 = v.out, ((i$1 < 0 || i$1 >= x$1.$length) ? $throwRuntimeError("index out of range") : x$1.$array[x$1.$offset + i$1])))) { + return false; + } + _i$1++; + } + return true; + } else if (_3 === (20)) { + t$1 = T.kindType; + v$1 = V.kindType; + if ((t$1.methods.$length === 0) && (v$1.methods.$length === 0)) { + return true; + } + return false; + } else if (_3 === (21)) { + return $interfaceIsEqual(T.Key(), V.Key()) && $interfaceIsEqual(T.Elem(), V.Elem()); + } else if ((_3 === (22)) || (_3 === (23))) { + return $interfaceIsEqual(T.Elem(), V.Elem()); + } else if (_3 === (25)) { + t$2 = T.kindType; + v$2 = V.kindType; + if (!((t$2.fields.$length === v$2.fields.$length))) { + return false; + } + _ref$2 = t$2.fields; + _i$2 = 0; + while (true) { + if (!(_i$2 < _ref$2.$length)) { break; } + i$2 = _i$2; + tf = (x$2 = t$2.fields, ((i$2 < 0 || i$2 >= x$2.$length) ? $throwRuntimeError("index out of range") : x$2.$array[x$2.$offset + i$2])); + vf = (x$3 = v$2.fields, ((i$2 < 0 || i$2 >= x$3.$length) ? $throwRuntimeError("index out of range") : x$3.$array[x$3.$offset + i$2])); + if (!(tf.name === vf.name) && (tf.name === ptrType$6.nil || vf.name === ptrType$6.nil || !(tf.name.$get() === vf.name.$get()))) { + return false; + } + if (!(tf.pkgPath === vf.pkgPath) && (tf.pkgPath === ptrType$6.nil || vf.pkgPath === ptrType$6.nil || !(tf.pkgPath.$get() === vf.pkgPath.$get()))) { + return false; + } + if (!(tf.typ === vf.typ)) { + return false; + } + if (!(tf.tag === vf.tag) && (tf.tag === ptrType$6.nil || vf.tag === ptrType$6.nil || !(tf.tag.$get() === vf.tag.$get()))) { + return false; + } + if (!((tf.offset === vf.offset))) { + return false; + } + _i$2++; + } + return true; + } + return false; + }; + toType = function(t) { + var $ptr, t; + if (t === ptrType$1.nil) { + return $ifaceNil; + } + return t; + }; + ifaceIndir = function(t) { + var $ptr, t; + return ((t.kind & 32) >>> 0) === 0; + }; + flag.prototype.kind = function() { + var $ptr, f; + f = this.$val; + return (((f & 31) >>> 0) >>> 0); + }; + $ptrType(flag).prototype.kind = function() { return new flag(this.$get()).kind(); }; + Value.ptr.prototype.pointer = function() { + var $ptr, 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 $ptr, 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 $ptr, 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 $ptr, 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 $ptr, 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 $ptr, 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, ((((v.flag & 96) >>> 0)) | 22) >>> 0); + }; + Value.prototype.Addr = function() { return this.$val.Addr(); }; + Value.ptr.prototype.Bool = function() { + var $ptr, 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 $ptr, _r, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _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: + return v.ptr.$get(); + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Bytes }; } $f.$ptr = $ptr; $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 $ptr, _r, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _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: + return v.ptr.$get(); + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.runes }; } $f.$ptr = $ptr; $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 $ptr, v; + v = this; + return !((((v.flag & 256) >>> 0) === 0)); + }; + Value.prototype.CanAddr = function() { return this.$val.CanAddr(); }; + Value.ptr.prototype.CanSet = function() { + var $ptr, 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 $ptr, _r, in$1, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _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 = v.call("Call", in$1); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ $s = 2; case 2: + return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Call }; } $f.$ptr = $ptr; $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 $ptr, _r, in$1, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _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 = v.call("CallSlice", in$1); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ $s = 2; case 2: + return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.CallSlice }; } $f.$ptr = $ptr; $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 $ptr, _2, k, v, x; + v = this; + k = new flag(v.flag).kind(); + _2 = k; + if (_2 === (15)) { + return (x = v.ptr.$get(), new $Complex128(x.$real, x.$imag)); + } else if (_2 === (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 $ptr, _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; $ptr = $f.$ptr; _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 = v.Field((0 >= index.$length ? $throwRuntimeError("index out of range") : index.$array[index.$offset + 0])); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ $s = 4; case 4: + return _r; + /* } */ case 2: + new flag(v.flag).mustBe(25); + _ref = index; + _i = 0; + /* while (true) { */ case 5: + /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 6; continue; } + i = _i; + x = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]); + /* */ if (i > 0) { $s = 7; continue; } + /* */ $s = 8; continue; + /* if (i > 0) { */ case 7: + if (!(v.Kind() === 22)) { _v = false; $s = 11; continue s; } + _r$1 = v.typ.Elem().Kind(); /* */ $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 === 25; case 11: + /* */ if (_v) { $s = 9; continue; } + /* */ $s = 10; continue; + /* if (_v) { */ case 9: + if (v.IsNil()) { + $panic(new $String("reflect: indirection through nil pointer to embedded struct")); + } + _r$2 = v.Elem(); /* */ $s = 13; case 13: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + v = _r$2; + /* } */ case 10: + /* } */ case 8: + _r$3 = v.Field(x); /* */ $s = 14; case 14: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + v = _r$3; + _i++; + /* } */ $s = 5; continue; case 6: + return v; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.FieldByIndex }; } $f.$ptr = $ptr; $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) { + var $ptr, _r, _r$1, _tuple, f, name, ok, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; f = $f.f; name = $f.name; 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); /* */ $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 = v.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 = 5; case 5: + return _r$1; + /* } */ case 3: + return new Value.ptr(ptrType$1.nil, 0, 0); + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.FieldByName }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.f = f; $f.name = name; $f.ok = ok; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + Value.prototype.FieldByName = function(name) { return this.$val.FieldByName(name); }; + Value.ptr.prototype.FieldByNameFunc = function(match) { + var $ptr, _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; $ptr = $f.$ptr; _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 = v.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 = 5; case 5: + return _r$1; + /* } */ case 3: + return new Value.ptr(ptrType$1.nil, 0, 0); + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.FieldByNameFunc }; } $f.$ptr = $ptr; $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 $ptr, _4, k, v; + v = this; + k = new flag(v.flag).kind(); + _4 = k; + if (_4 === (13)) { + return v.ptr.$get(); + } else if (_4 === (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 $ptr, _6, k, p, v; + v = this; + k = new flag(v.flag).kind(); + p = v.ptr; + _6 = k; + if (_6 === (2)) { + return new $Int64(0, p.$get()); + } else if (_6 === (3)) { + return new $Int64(0, p.$get()); + } else if (_6 === (4)) { + return new $Int64(0, p.$get()); + } else if (_6 === (5)) { + return new $Int64(0, p.$get()); + } else if (_6 === (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 $ptr, 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 $ptr, _r, i, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _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(v, true); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + i = _r; + /* */ $s = 2; case 2: + return i; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Interface }; } $f.$ptr = $ptr; $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 $ptr, v; + v = this; + return !((v.flag === 0)); + }; + Value.prototype.IsValid = function() { return this.$val.IsValid(); }; + Value.ptr.prototype.Kind = function() { + var $ptr, v; + v = this; + return new flag(v.flag).kind(); + }; + Value.prototype.Kind = function() { return this.$val.Kind(); }; + Value.ptr.prototype.MapIndex = function(key) { + var $ptr, _r, c, 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; $ptr = $f.$ptr; _r = $f._r; c = $f.c; 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: + key = key; + v = this; + new flag(v.flag).mustBe(21); + tt = v.typ.kindType; + _r = key.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$18(function() { return this.$target.ptr; }, function($v) { this.$target.ptr = $v; }, key))); + } + e = mapaccess(v.typ, v.pointer(), k); + if (e === 0) { + return new Value.ptr(ptrType$1.nil, 0, 0); + } + typ = tt.elem; + fl = ((((v.flag | key.flag) >>> 0)) & 96) >>> 0; + fl = (fl | ((typ.Kind() >>> 0))) >>> 0; + if (ifaceIndir(typ)) { + c = unsafe_New(typ); + typedmemmove(typ, c, e); + return new Value.ptr(typ, c, (fl | 128) >>> 0); + } else { + return new Value.ptr(typ, e.$get(), fl); + } + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.MapIndex }; } $f.$ptr = $ptr; $f._r = _r; $f.c = c; $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 $ptr, _r, a, c, 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; $ptr = $f.$ptr; _r = $f._r; a = $f.a; c = $f.c; 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 = (((v.flag & 96) >>> 0) | (keyType.Kind() >>> 0)) >>> 0; + m = v.pointer(); + mlen = 0; + if (!(m === 0)) { + mlen = maplen(m); + } + it = mapiterinit(v.typ, m); + a = $makeSlice(sliceType$8, 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; + } + if (ifaceIndir(keyType)) { + c = unsafe_New(keyType); + typedmemmove(keyType, c, key); + ((i < 0 || i >= a.$length) ? $throwRuntimeError("index out of range") : a.$array[a.$offset + i] = new Value.ptr(keyType, c, (fl | 128) >>> 0)); + } else { + ((i < 0 || i >= a.$length) ? $throwRuntimeError("index out of range") : a.$array[a.$offset + i] = new Value.ptr(keyType, key.$get(), fl)); + } + mapiternext(it); + i = i + (1) >> 0; + /* } */ $s = 1; continue; case 2: + return $subslice(a, 0, i); + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.MapKeys }; } $f.$ptr = $ptr; $f._r = _r; $f.a = a; $f.c = c; $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(); }; + Value.ptr.prototype.Method = function(i) { + var $ptr, 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) && v.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 $ptr, 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) { + var $ptr, _tuple, m, name, ok, v; + v = this; + if (v.typ === ptrType$1.nil) { + $panic(new ValueError.ptr("reflect.Value.MethodByName", 0)); + } + if (!((((v.flag & 512) >>> 0) === 0))) { + return new Value.ptr(ptrType$1.nil, 0, 0); + } + _tuple = v.typ.MethodByName(name); + m = $clone(_tuple[0], Method); + ok = _tuple[1]; + if (!ok) { + return new Value.ptr(ptrType$1.nil, 0, 0); + } + return v.Method(m.Index); + }; + Value.prototype.MethodByName = function(name) { return this.$val.MethodByName(name); }; + Value.ptr.prototype.NumField = function() { + var $ptr, 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 $ptr, _9, k, v, x; + v = this; + k = new flag(v.flag).kind(); + _9 = k; + if (_9 === (15)) { + return overflowFloat32(x.$real) || overflowFloat32(x.$imag); + } else if (_9 === (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 $ptr, _10, k, v, x; + v = this; + k = new flag(v.flag).kind(); + _10 = k; + if (_10 === (13)) { + return overflowFloat32(x); + } else if (_10 === (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 $ptr, x; + if (x < 0) { + x = -x; + } + return 3.4028234663852886e+38 < x && x <= 1.7976931348623157e+308; + }; + Value.ptr.prototype.OverflowInt = function(x) { + var $ptr, _11, bitSize, k, trunc, v, x; + v = this; + k = new flag(v.flag).kind(); + _11 = k; + if ((_11 === (2)) || (_11 === (3)) || (_11 === (4)) || (_11 === (5)) || (_11 === (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 $ptr, _12, bitSize, k, trunc, v, x; + v = this; + k = new flag(v.flag).kind(); + _12 = k; + if ((_12 === (7)) || (_12 === (12)) || (_12 === (8)) || (_12 === (9)) || (_12 === (10)) || (_12 === (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 $ptr, _r, _tuple, ok, v, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _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 = v.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 = 2; case 2: + return [x, ok]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Recv }; } $f.$ptr = $ptr; $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 $ptr, _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; $ptr = $f.$ptr; _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$18(function() { return this.$target.ptr; }, function($v) { this.$target.ptr = $v; }, val))); + } + _r = chanrecv(v.typ, v.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); + } + return [val, ok]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.recv }; } $f.$ptr = $ptr; $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 $ptr, _r, v, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + x = x; + v = this; + new flag(v.flag).mustBe(18); + new flag(v.flag).mustBeExported(); + _r = v.send(x, false); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _r; + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Send }; } $f.$ptr = $ptr; $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 $ptr, _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; $ptr = $f.$ptr; _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; + x = x; + 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 = x.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$18(function() { return this.$target.ptr; }, function($v) { this.$target.ptr = $v; }, x))); + } + _r$1 = chansend(v.typ, v.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 = 3; case 3: + return selected; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.send }; } $f.$ptr = $ptr; $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 $ptr, 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 $ptr, _r, v, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _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; case -1: } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.setRunes }; } $f.$ptr = $ptr; $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 $ptr, _14, k, v, x; + v = this; + new flag(v.flag).mustBeAssignable(); + k = new flag(v.flag).kind(); + _14 = k; + if (_14 === (15)) { + v.ptr.$set(new $Complex64(x.$real, x.$imag)); + } else if (_14 === (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 $ptr, _15, k, v, x; + v = this; + new flag(v.flag).mustBeAssignable(); + k = new flag(v.flag).kind(); + _15 = k; + if (_15 === (13)) { + v.ptr.$set($fround(x)); + } else if (_15 === (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 $ptr, _16, k, v, x; + v = this; + new flag(v.flag).mustBeAssignable(); + k = new flag(v.flag).kind(); + _16 = k; + if (_16 === (2)) { + v.ptr.$set(((x.$low + ((x.$high >> 31) * 4294967296)) >> 0)); + } else if (_16 === (3)) { + v.ptr.$set(((x.$low + ((x.$high >> 31) * 4294967296)) << 24 >> 24)); + } else if (_16 === (4)) { + v.ptr.$set(((x.$low + ((x.$high >> 31) * 4294967296)) << 16 >> 16)); + } else if (_16 === (5)) { + v.ptr.$set(((x.$low + ((x.$high >> 31) * 4294967296)) >> 0)); + } else if (_16 === (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 $ptr, _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; $ptr = $f.$ptr; _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: + val = val; + key = key; + v = this; + new flag(v.flag).mustBe(21); + new flag(v.flag).mustBeExported(); + new flag(key.flag).mustBeExported(); + tt = v.typ.kindType; + _r = key.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$18(function() { return this.$target.ptr; }, function($v) { this.$target.ptr = $v; }, key))); + } + if (val.typ === ptrType$1.nil) { + mapdelete(v.typ, v.pointer(), k); + return; + } + new flag(val.flag).mustBeExported(); + _r$1 = val.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$18(function() { return this.$target.ptr; }, function($v) { this.$target.ptr = $v; }, val))); + } + $r = mapassign(v.typ, v.pointer(), k, e); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.SetMapIndex }; } $f.$ptr = $ptr; $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 $ptr, _17, k, v, x; + v = this; + new flag(v.flag).mustBeAssignable(); + k = new flag(v.flag).kind(); + _17 = k; + if (_17 === (7)) { + v.ptr.$set((x.$low >>> 0)); + } else if (_17 === (8)) { + v.ptr.$set((x.$low << 24 >>> 24)); + } else if (_17 === (9)) { + v.ptr.$set((x.$low << 16 >>> 16)); + } else if (_17 === (10)) { + v.ptr.$set((x.$low >>> 0)); + } else if (_17 === (11)) { + v.ptr.$set(x); + } else if (_17 === (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 $ptr, 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 $ptr, 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 $ptr, _20, _r, k, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _20 = $f._20; _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(); + _20 = k; + if (_20 === (0)) { + return ""; + } else if (_20 === (24)) { + return v.ptr.$get(); + } + _r = v.Type().String(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ $s = 2; case 2: + return "<" + _r + " Value>"; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.String }; } $f.$ptr = $ptr; $f._20 = _20; $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 $ptr, _r, _tuple, ok, v, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _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 = v.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 = 2; case 2: + return [x, ok]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.TryRecv }; } $f.$ptr = $ptr; $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 $ptr, _r, v, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + x = x; + v = this; + new flag(v.flag).mustBe(18); + new flag(v.flag).mustBeExported(); + _r = v.send(x, true); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ $s = 2; case 2: + return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.TrySend }; } $f.$ptr = $ptr; $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 $ptr, f, i, m, m$1, tt, ut, v, x, x$1; + 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") : x.$array[x.$offset + i])); + return m.typ; + } + ut = v.typ.uncommonType.uncommon(); + if (ut === ptrType$7.nil || (i >>> 0) >= (ut.methods.$length >>> 0)) { + $panic(new $String("reflect: internal error: invalid method index")); + } + m$1 = (x$1 = ut.methods, ((i < 0 || i >= x$1.$length) ? $throwRuntimeError("index out of range") : x$1.$array[x$1.$offset + i])); + return m$1.mtyp; + }; + Value.prototype.Type = function() { return this.$val.Type(); }; + Value.ptr.prototype.Uint = function() { + var $ptr, _21, k, p, v, x; + v = this; + k = new flag(v.flag).kind(); + p = v.ptr; + _21 = k; + if (_21 === (7)) { + return new $Uint64(0, p.$get()); + } else if (_21 === (8)) { + return new $Uint64(0, p.$get()); + } else if (_21 === (9)) { + return new $Uint64(0, p.$get()); + } else if (_21 === (10)) { + return new $Uint64(0, p.$get()); + } else if (_21 === (11)) { + return p.$get(); + } else if (_21 === (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 $ptr, 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 $ptr, _r, _r$1, fl, ptr, typ, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; fl = $f.fl; ptr = $f.ptr; typ = $f.typ; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + if ($interfaceIsEqual(typ, $ifaceNil)) { + $panic(new $String("reflect: New(nil)")); + } + ptr = unsafe_New($assertType(typ, ptrType$1)); + fl = 22; + _r = typ.common(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _r$1 = _r.ptrTo(); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + /* */ $s = 3; case 3: + return new Value.ptr(_r$1, ptr, fl); + /* */ } return; } if ($f === undefined) { $f = { $blk: New }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f.fl = fl; $f.ptr = ptr; $f.typ = typ; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.New = New; + Value.ptr.prototype.assignTo = function(context, dst, target) { + var $ptr, _r, _r$1, context, dst, fl, target, v, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; 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, v); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + v = _r; + /* } */ case 2: + /* */ if (directlyAssignable(dst, v.typ)) { $s = 5; continue; } + /* */ if (implements$1(dst, v.typ)) { $s = 6; continue; } + /* */ $s = 7; continue; + /* if (directlyAssignable(dst, v.typ)) { */ case 5: + v.typ = dst; + fl = (v.flag & 480) >>> 0; + fl = (fl | ((dst.Kind() >>> 0))) >>> 0; + 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$1 = valueInterface(v, false); /* */ $s = 8; case 8: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + x = _r$1; + if (dst.NumMethod() === 0) { + target.$set(x); + } else { + ifaceE2I(dst, x, target); + } + 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; case -1: } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.assignTo }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $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.Convert = function(t) { + var $ptr, _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; $ptr = $f.$ptr; _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", v); /* */ $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(v, t); /* */ $s = 9; case 9: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + /* */ $s = 10; case 10: + return _r$4; + /* */ } return; } if ($f === undefined) { $f = { $blk: Value.ptr.prototype.Convert }; } $f.$ptr = $ptr; $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 $ptr, _23, _24, _25, _26, _27, _28, _29, _arg, _arg$1, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _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; $ptr = $f.$ptr; _23 = $f._23; _24 = $f._24; _25 = $f._25; _26 = $f._26; _27 = $f._27; _28 = $f._28; _29 = $f._29; _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; _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: + _23 = src.Kind(); + /* */ if ((_23 === (2)) || (_23 === (3)) || (_23 === (4)) || (_23 === (5)) || (_23 === (6))) { $s = 2; continue; } + /* */ if ((_23 === (7)) || (_23 === (8)) || (_23 === (9)) || (_23 === (10)) || (_23 === (11)) || (_23 === (12))) { $s = 3; continue; } + /* */ if ((_23 === (13)) || (_23 === (14))) { $s = 4; continue; } + /* */ if ((_23 === (15)) || (_23 === (16))) { $s = 5; continue; } + /* */ if (_23 === (24)) { $s = 6; continue; } + /* */ if (_23 === (23)) { $s = 7; continue; } + /* */ $s = 8; continue; + /* if ((_23 === (2)) || (_23 === (3)) || (_23 === (4)) || (_23 === (5)) || (_23 === (6))) { */ case 2: + _24 = dst.Kind(); + if ((_24 === (2)) || (_24 === (3)) || (_24 === (4)) || (_24 === (5)) || (_24 === (6)) || (_24 === (7)) || (_24 === (8)) || (_24 === (9)) || (_24 === (10)) || (_24 === (11)) || (_24 === (12))) { + return cvtInt; + } else if ((_24 === (13)) || (_24 === (14))) { + return cvtIntFloat; + } else if (_24 === (24)) { + return cvtIntString; + } + $s = 8; continue; + /* } else if ((_23 === (7)) || (_23 === (8)) || (_23 === (9)) || (_23 === (10)) || (_23 === (11)) || (_23 === (12))) { */ case 3: + _25 = dst.Kind(); + if ((_25 === (2)) || (_25 === (3)) || (_25 === (4)) || (_25 === (5)) || (_25 === (6)) || (_25 === (7)) || (_25 === (8)) || (_25 === (9)) || (_25 === (10)) || (_25 === (11)) || (_25 === (12))) { + return cvtUint; + } else if ((_25 === (13)) || (_25 === (14))) { + return cvtUintFloat; + } else if (_25 === (24)) { + return cvtUintString; + } + $s = 8; continue; + /* } else if ((_23 === (13)) || (_23 === (14))) { */ case 4: + _26 = dst.Kind(); + if ((_26 === (2)) || (_26 === (3)) || (_26 === (4)) || (_26 === (5)) || (_26 === (6))) { + return cvtFloatInt; + } else if ((_26 === (7)) || (_26 === (8)) || (_26 === (9)) || (_26 === (10)) || (_26 === (11)) || (_26 === (12))) { + return cvtFloatUint; + } else if ((_26 === (13)) || (_26 === (14))) { + return cvtFloat; + } + $s = 8; continue; + /* } else if ((_23 === (15)) || (_23 === (16))) { */ case 5: + _27 = dst.Kind(); + if ((_27 === (15)) || (_27 === (16))) { + return cvtComplex; + } + $s = 8; continue; + /* } else if (_23 === (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; } + _28 = _r$1; + if (_28 === (8)) { + return cvtStringBytes; + } else if (_28 === (5)) { + return cvtStringRunes; + } + case 13: + /* } */ case 10: + $s = 8; continue; + /* } else if (_23 === (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; } + _29 = _r$3; + if (_29 === (8)) { + return cvtBytesString; + } else if (_29 === (5)) { + return cvtRunesString; + } + case 19: + /* } */ case 16: + /* } */ case 8: + case 1: + if (haveIdenticalUnderlyingType(dst, src)) { + return cvtDirect; + } + if (!((dst.Kind() === 22) && dst.Name() === "" && (src.Kind() === 22) && src.Name() === "")) { _v$2 = false; $s = 23; continue s; } + _r$4 = dst.Elem().common(); /* */ $s = 24; case 24: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + _arg = _r$4; + _r$5 = src.Elem().common(); /* */ $s = 25; case 25: 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); /* */ $s = 26; case 26: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + _v$2 = _r$6; case 23: + /* */ if (_v$2) { $s = 21; continue; } + /* */ $s = 22; continue; + /* if (_v$2) { */ case 21: + return cvtDirect; + /* } */ case 22: + if (implements$1(dst, src)) { + if (src.Kind() === 20) { + return cvtI2I; + } + return cvtT2I; + } + return $throwNilPointerError; + /* */ } return; } if ($f === undefined) { $f = { $blk: convertOp }; } $f.$ptr = $ptr; $f._23 = _23; $f._24 = _24; $f._25 = _25; $f._26 = _26; $f._27 = _27; $f._28 = _28; $f._29 = _29; $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._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 $ptr, _31, _r, f, ptr, t, typ, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _31 = $f._31; _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); + _31 = typ.size; + if (_31 === (4)) { + ptr.$set($fround(v)); + } else if (_31 === (8)) { + ptr.$set(v); + } + return new Value.ptr(typ, ptr, (((f | 128) >>> 0) | (typ.Kind() >>> 0)) >>> 0); + /* */ } return; } if ($f === undefined) { $f = { $blk: makeFloat }; } $f.$ptr = $ptr; $f._31 = _31; $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 $ptr, _32, _r, f, ptr, t, typ, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _32 = $f._32; _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); + _32 = typ.size; + if (_32 === (8)) { + ptr.$set(new $Complex64(v.$real, v.$imag)); + } else if (_32 === (16)) { + ptr.$set(v); + } + return new Value.ptr(typ, ptr, (((f | 128) >>> 0) | (typ.Kind() >>> 0)) >>> 0); + /* */ } return; } if ($f === undefined) { $f = { $blk: makeComplex }; } $f.$ptr = $ptr; $f._32 = _32; $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 $ptr, _r, _r$1, f, ret, t, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; 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 = New(t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _r$1 = _r.Elem(); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + ret = _r$1; + ret.SetString(v); + ret.flag = (((ret.flag & ~256) >>> 0) | f) >>> 0; + return ret; + /* */ } return; } if ($f === undefined) { $f = { $blk: makeString }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $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 $ptr, _r, _r$1, f, ret, t, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; 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 = New(t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _r$1 = _r.Elem(); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + ret = _r$1; + $r = ret.SetBytes(v); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + ret.flag = (((ret.flag & ~256) >>> 0) | f) >>> 0; + return ret; + /* */ } return; } if ($f === undefined) { $f = { $blk: makeBytes }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $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 $ptr, _r, _r$1, f, ret, t, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; 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 = New(t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _r$1 = _r.Elem(); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + ret = _r$1; + $r = ret.setRunes(v); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + ret.flag = (((ret.flag & ~256) >>> 0) | f) >>> 0; + return ret; + /* */ } return; } if ($f === undefined) { $f = { $blk: makeRunes }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $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 $ptr, _r, t, v, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _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: + v = v; + _r = makeInt((v.flag & 96) >>> 0, (x = v.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 = 2; case 2: + return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: cvtInt }; } $f.$ptr = $ptr; $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 $ptr, _r, t, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = v; + _r = makeInt((v.flag & 96) >>> 0, v.Uint(), t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ $s = 2; case 2: + return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: cvtUint }; } $f.$ptr = $ptr; $f._r = _r; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + cvtFloatInt = function(v, t) { + var $ptr, _r, t, v, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _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: + v = v; + _r = makeInt((v.flag & 96) >>> 0, (x = new $Int64(0, v.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 = 2; case 2: + return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: cvtFloatInt }; } $f.$ptr = $ptr; $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 $ptr, _r, t, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = v; + _r = makeInt((v.flag & 96) >>> 0, new $Uint64(0, v.Float()), t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ $s = 2; case 2: + return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: cvtFloatUint }; } $f.$ptr = $ptr; $f._r = _r; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + cvtIntFloat = function(v, t) { + var $ptr, _r, t, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = v; + _r = makeFloat((v.flag & 96) >>> 0, $flatten64(v.Int()), t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ $s = 2; case 2: + return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: cvtIntFloat }; } $f.$ptr = $ptr; $f._r = _r; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + cvtUintFloat = function(v, t) { + var $ptr, _r, t, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = v; + _r = makeFloat((v.flag & 96) >>> 0, $flatten64(v.Uint()), t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ $s = 2; case 2: + return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: cvtUintFloat }; } $f.$ptr = $ptr; $f._r = _r; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + cvtFloat = function(v, t) { + var $ptr, _r, t, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = v; + _r = makeFloat((v.flag & 96) >>> 0, v.Float(), t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ $s = 2; case 2: + return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: cvtFloat }; } $f.$ptr = $ptr; $f._r = _r; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + cvtComplex = function(v, t) { + var $ptr, _r, t, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = v; + _r = makeComplex((v.flag & 96) >>> 0, v.Complex(), t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ $s = 2; case 2: + return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: cvtComplex }; } $f.$ptr = $ptr; $f._r = _r; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + cvtIntString = function(v, t) { + var $ptr, _r, t, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = v; + _r = makeString((v.flag & 96) >>> 0, $encodeRune(v.Int().$low), t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ $s = 2; case 2: + return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: cvtIntString }; } $f.$ptr = $ptr; $f._r = _r; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + cvtUintString = function(v, t) { + var $ptr, _r, t, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; t = $f.t; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = v; + _r = makeString((v.flag & 96) >>> 0, $encodeRune(v.Uint().$low), t); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ $s = 2; case 2: + return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: cvtUintString }; } $f.$ptr = $ptr; $f._r = _r; $f.t = t; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + cvtBytesString = function(v, t) { + var $ptr, _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; $ptr = $f.$ptr; _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: + v = v; + _arg = (v.flag & 96) >>> 0; + _r = v.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 = 3; case 3: + return _r$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: cvtBytesString }; } $f.$ptr = $ptr; $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 $ptr, _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; $ptr = $f.$ptr; _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: + v = v; + _arg = (v.flag & 96) >>> 0; + _r = v.String(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _arg$1 = new sliceType$13($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 = 3; case 3: + return _r$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: cvtStringBytes }; } $f.$ptr = $ptr; $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 $ptr, _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; $ptr = $f.$ptr; _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: + v = v; + _arg = (v.flag & 96) >>> 0; + _r = v.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 = 3; case 3: + return _r$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: cvtRunesString }; } $f.$ptr = $ptr; $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 $ptr, _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; $ptr = $f.$ptr; _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: + v = v; + _arg = (v.flag & 96) >>> 0; + _r = v.String(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _arg$1 = new sliceType$15($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 = 3; case 3: + return _r$1; + /* */ } return; } if ($f === undefined) { $f = { $blk: cvtStringRunes }; } $f.$ptr = $ptr; $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 $ptr, _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; $ptr = $f.$ptr; _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: + v = v; + _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(v, 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 = 9; case 9: + return new Value.ptr(_r$4, target, (((((v.flag & 96) >>> 0) | 128) >>> 0) | 20) >>> 0); + /* */ } return; } if ($f === undefined) { $f = { $blk: cvtT2I }; } $f.$ptr = $ptr; $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 $ptr, _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; $ptr = $f.$ptr; _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: + v = v; + /* */ if (v.IsNil()) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (v.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 | (((v.flag & 96) >>> 0))) >>> 0; + return ret; + /* } */ case 2: + _r$1 = v.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(_r$1, typ); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + /* */ $s = 6; case 6: + return _r$2; + /* */ } return; } if ($f === undefined) { $f = { $blk: cvtI2I }; } $f.$ptr = $ptr; $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; + }; + Kind.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}]; + ptrType$1.methods = [{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: "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: "NumMethod", name: "NumMethod", 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: "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$11], [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)}]; + ptrType$7.methods = [{prop: "Method", name: "Method", pkg: "", typ: $funcType([$Int], [Method], false)}, {prop: "uncommon", name: "uncommon", pkg: "reflect", typ: $funcType([], [ptrType$7], false)}, {prop: "PkgPath", name: "PkgPath", pkg: "", typ: $funcType([], [$String], false)}, {prop: "Name", name: "Name", pkg: "", typ: $funcType([], [$String], false)}, {prop: "NumMethod", name: "NumMethod", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "MethodByName", name: "MethodByName", pkg: "", typ: $funcType([$String], [Method, $Bool], false)}]; + ChanDir.methods = [{prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}]; + ptrType$11.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$13.methods = [{prop: "Field", name: "Field", pkg: "", typ: $funcType([$Int], [StructField], false)}, {prop: "FieldByIndex", name: "FieldByIndex", pkg: "", typ: $funcType([sliceType$11], [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)}]; + Value.methods = [{prop: "object", name: "object", pkg: "reflect", typ: $funcType([], [ptrType$3], false)}, {prop: "call", name: "call", pkg: "reflect", typ: $funcType([$String, sliceType$8], [sliceType$8], 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$3], 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$13], [], 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$13], false)}, {prop: "runes", name: "runes", pkg: "reflect", typ: $funcType([], [sliceType$15], 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$8], [sliceType$8], false)}, {prop: "CallSlice", name: "CallSlice", pkg: "", typ: $funcType([sliceType$8], [sliceType$8], false)}, {prop: "Complex", name: "Complex", pkg: "", typ: $funcType([], [$Complex128], false)}, {prop: "FieldByIndex", name: "FieldByIndex", pkg: "", typ: $funcType([sliceType$11], [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$8], 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$15], [], 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: "assignTo", name: "assignTo", pkg: "reflect", typ: $funcType([$String, ptrType$1, $UnsafePointer], [Value], false)}, {prop: "Convert", name: "Convert", pkg: "", typ: $funcType([Type], [Value], false)}]; + flag.methods = [{prop: "kind", name: "kind", pkg: "reflect", typ: $funcType([], [Kind], 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)}]; + mapIter.init([{prop: "t", name: "t", pkg: "reflect", typ: Type, tag: ""}, {prop: "m", name: "m", pkg: "reflect", typ: ptrType$3, tag: ""}, {prop: "keys", name: "keys", pkg: "reflect", typ: ptrType$3, tag: ""}, {prop: "i", name: "i", pkg: "reflect", typ: $Int, 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$11], [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$7], false)}]); + rtype.init([{prop: "size", name: "size", pkg: "reflect", typ: $Uintptr, tag: ""}, {prop: "ptrdata", name: "ptrdata", pkg: "reflect", typ: $Uintptr, tag: ""}, {prop: "hash", name: "hash", pkg: "reflect", typ: $Uint32, tag: ""}, {prop: "_$3", name: "_", pkg: "reflect", typ: $Uint8, tag: ""}, {prop: "align", name: "align", pkg: "reflect", typ: $Uint8, tag: ""}, {prop: "fieldAlign", name: "fieldAlign", pkg: "reflect", typ: $Uint8, tag: ""}, {prop: "kind", name: "kind", pkg: "reflect", typ: $Uint8, tag: ""}, {prop: "alg", name: "alg", pkg: "reflect", typ: ptrType$4, tag: ""}, {prop: "gcdata", name: "gcdata", pkg: "reflect", typ: ptrType$5, tag: ""}, {prop: "string", name: "string", pkg: "reflect", typ: ptrType$6, tag: ""}, {prop: "uncommonType", name: "", pkg: "reflect", typ: ptrType$7, tag: ""}, {prop: "ptrToThis", name: "ptrToThis", pkg: "reflect", typ: ptrType$1, tag: ""}]); + typeAlg.init([{prop: "hash", name: "hash", pkg: "reflect", typ: funcType$4, tag: ""}, {prop: "equal", name: "equal", pkg: "reflect", typ: funcType$5, tag: ""}]); + method.init([{prop: "name", name: "name", pkg: "reflect", typ: ptrType$6, tag: ""}, {prop: "pkgPath", name: "pkgPath", pkg: "reflect", typ: ptrType$6, tag: ""}, {prop: "mtyp", name: "mtyp", pkg: "reflect", typ: ptrType$1, tag: ""}, {prop: "typ", name: "typ", pkg: "reflect", typ: ptrType$1, tag: ""}, {prop: "ifn", name: "ifn", pkg: "reflect", typ: $UnsafePointer, tag: ""}, {prop: "tfn", name: "tfn", pkg: "reflect", typ: $UnsafePointer, tag: ""}]); + uncommonType.init([{prop: "name", name: "name", pkg: "reflect", typ: ptrType$6, tag: ""}, {prop: "pkgPath", name: "pkgPath", pkg: "reflect", typ: ptrType$6, tag: ""}, {prop: "methods", name: "methods", pkg: "reflect", typ: sliceType$4, tag: ""}]); + arrayType.init([{prop: "rtype", name: "", pkg: "reflect", typ: rtype, tag: "reflect:\"array\""}, {prop: "elem", name: "elem", pkg: "reflect", typ: ptrType$1, tag: ""}, {prop: "slice", name: "slice", pkg: "reflect", typ: ptrType$1, tag: ""}, {prop: "len", name: "len", pkg: "reflect", typ: $Uintptr, tag: ""}]); + chanType.init([{prop: "rtype", name: "", pkg: "reflect", typ: rtype, tag: "reflect:\"chan\""}, {prop: "elem", name: "elem", pkg: "reflect", typ: ptrType$1, tag: ""}, {prop: "dir", name: "dir", pkg: "reflect", typ: $Uintptr, tag: ""}]); + funcType.init([{prop: "rtype", name: "", pkg: "reflect", typ: rtype, tag: "reflect:\"func\""}, {prop: "dotdotdot", name: "dotdotdot", pkg: "reflect", typ: $Bool, tag: ""}, {prop: "in$2", name: "in", pkg: "reflect", typ: sliceType$1, tag: ""}, {prop: "out", name: "out", pkg: "reflect", typ: sliceType$1, tag: ""}]); + imethod.init([{prop: "name", name: "name", pkg: "reflect", typ: ptrType$6, tag: ""}, {prop: "pkgPath", name: "pkgPath", pkg: "reflect", typ: ptrType$6, tag: ""}, {prop: "typ", name: "typ", pkg: "reflect", typ: ptrType$1, tag: ""}]); + interfaceType.init([{prop: "rtype", name: "", pkg: "reflect", typ: rtype, tag: "reflect:\"interface\""}, {prop: "methods", name: "methods", pkg: "reflect", typ: sliceType$5, tag: ""}]); + mapType.init([{prop: "rtype", name: "", pkg: "reflect", typ: rtype, tag: "reflect:\"map\""}, {prop: "key", name: "key", pkg: "reflect", typ: ptrType$1, tag: ""}, {prop: "elem", name: "elem", pkg: "reflect", typ: ptrType$1, tag: ""}, {prop: "bucket", name: "bucket", pkg: "reflect", typ: ptrType$1, tag: ""}, {prop: "hmap", name: "hmap", pkg: "reflect", typ: ptrType$1, tag: ""}, {prop: "keysize", name: "keysize", pkg: "reflect", typ: $Uint8, tag: ""}, {prop: "indirectkey", name: "indirectkey", pkg: "reflect", typ: $Uint8, tag: ""}, {prop: "valuesize", name: "valuesize", pkg: "reflect", typ: $Uint8, tag: ""}, {prop: "indirectvalue", name: "indirectvalue", pkg: "reflect", typ: $Uint8, tag: ""}, {prop: "bucketsize", name: "bucketsize", pkg: "reflect", typ: $Uint16, tag: ""}, {prop: "reflexivekey", name: "reflexivekey", pkg: "reflect", typ: $Bool, tag: ""}, {prop: "needkeyupdate", name: "needkeyupdate", pkg: "reflect", typ: $Bool, tag: ""}]); + ptrType.init([{prop: "rtype", name: "", pkg: "reflect", typ: rtype, tag: "reflect:\"ptr\""}, {prop: "elem", name: "elem", pkg: "reflect", typ: ptrType$1, tag: ""}]); + sliceType.init([{prop: "rtype", name: "", pkg: "reflect", typ: rtype, tag: "reflect:\"slice\""}, {prop: "elem", name: "elem", pkg: "reflect", typ: ptrType$1, tag: ""}]); + structField.init([{prop: "name", name: "name", pkg: "reflect", typ: ptrType$6, tag: ""}, {prop: "pkgPath", name: "pkgPath", pkg: "reflect", typ: ptrType$6, tag: ""}, {prop: "typ", name: "typ", pkg: "reflect", typ: ptrType$1, tag: ""}, {prop: "tag", name: "tag", pkg: "reflect", typ: ptrType$6, tag: ""}, {prop: "offset", name: "offset", pkg: "reflect", typ: $Uintptr, tag: ""}]); + structType.init([{prop: "rtype", name: "", pkg: "reflect", typ: rtype, tag: "reflect:\"struct\""}, {prop: "fields", name: "fields", pkg: "reflect", typ: sliceType$6, tag: ""}]); + Method.init([{prop: "Name", name: "Name", pkg: "", typ: $String, tag: ""}, {prop: "PkgPath", name: "PkgPath", pkg: "", typ: $String, tag: ""}, {prop: "Type", name: "Type", pkg: "", typ: Type, tag: ""}, {prop: "Func", name: "Func", pkg: "", typ: Value, tag: ""}, {prop: "Index", name: "Index", pkg: "", typ: $Int, tag: ""}]); + StructField.init([{prop: "Name", name: "Name", pkg: "", typ: $String, tag: ""}, {prop: "PkgPath", name: "PkgPath", pkg: "", typ: $String, tag: ""}, {prop: "Type", name: "Type", pkg: "", typ: Type, tag: ""}, {prop: "Tag", name: "Tag", pkg: "", typ: StructTag, tag: ""}, {prop: "Offset", name: "Offset", pkg: "", typ: $Uintptr, tag: ""}, {prop: "Index", name: "Index", pkg: "", typ: sliceType$11, tag: ""}, {prop: "Anonymous", name: "Anonymous", pkg: "", typ: $Bool, tag: ""}]); + fieldScan.init([{prop: "typ", name: "typ", pkg: "reflect", typ: ptrType$13, tag: ""}, {prop: "index", name: "index", pkg: "reflect", typ: sliceType$11, tag: ""}]); + Value.init([{prop: "typ", name: "typ", pkg: "reflect", typ: ptrType$1, tag: ""}, {prop: "ptr", name: "ptr", pkg: "reflect", typ: $UnsafePointer, tag: ""}, {prop: "flag", name: "", pkg: "reflect", typ: flag, tag: ""}]); + ValueError.init([{prop: "Method", name: "Method", pkg: "", typ: $String, tag: ""}, {prop: "Kind", name: "Kind", pkg: "", typ: Kind, tag: ""}]); + nonEmptyInterface.init([{prop: "itab", name: "itab", pkg: "reflect", typ: ptrType$9, tag: ""}, {prop: "word", name: "word", pkg: "reflect", 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; } + initialized = false; + stringPtrMap = {}; + callHelper = $assertType($internalize($call, $emptyInterface), funcType$1); + selectHelper = $assertType($internalize($select, $emptyInterface), funcType$1); + kindNames = new sliceType$3(["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"]); + jsObjectPtr = reflectType($jsObjectPtr); + uint8Type = $assertType(TypeOf(new $Uint8(0)), ptrType$1); + $r = 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["fmt"] = (function() { + var $pkg = {}, $init, errors, io, math, os, reflect, strconv, sync, utf8, fmtFlags, fmt, State, Formatter, Stringer, GoStringer, buffer, pp, runeUnreader, scanError, ss, ssave, sliceType, sliceType$1, ptrType, arrayType, arrayType$1, ptrType$1, arrayType$2, sliceType$2, ptrType$2, ptrType$5, ptrType$25, funcType, padZeroBytes, padSpaceBytes, trueBytes, falseBytes, commaSpaceBytes, nilAngleBytes, nilParenBytes, nilBytes, mapBytes, percentBangBytes, missingBytes, badIndexBytes, panicBytes, extraBytes, irparenBytes, bytesBytes, badWidthBytes, badPrecBytes, noVerbBytes, ppFree, intBits, uintptrBits, byteType, space, ssFree, complexError, boolError, _r, _r$1, init, doPrec, newPrinter, Fprintf, Sprintf, Errorf, Fprint, Fprintln, getField, tooLarge, parsenum, intFromArg, parseArgNumber, isSpace, notSpace, indexRune; + errors = $packages["errors"]; + 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", "fmtFlags", "fmt", function(widPresent_, precPresent_, minus_, plus_, sharp_, space_, unicode_, uniQuote_, 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.unicode = false; + this.uniQuote = 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.unicode = unicode_; + this.uniQuote = uniQuote_; + this.zero = zero_; + this.plusV = plusV_; + this.sharpV = sharpV_; + }); + fmt = $pkg.fmt = $newType(0, $kindStruct, "fmt.fmt", "fmt", "fmt", function(intbuf_, buf_, wid_, prec_, fmtFlags_) { + this.$val = this; + if (arguments.length === 0) { + this.intbuf = arrayType$1.zero(); + this.buf = ptrType$1.nil; + this.wid = 0; + this.prec = 0; + this.fmtFlags = new fmtFlags.ptr(false, false, false, false, false, false, false, false, false, false, false); + return; + } + this.intbuf = intbuf_; + this.buf = buf_; + this.wid = wid_; + this.prec = prec_; + this.fmtFlags = fmtFlags_; + }); + State = $pkg.State = $newType(8, $kindInterface, "fmt.State", "State", "fmt", null); + Formatter = $pkg.Formatter = $newType(8, $kindInterface, "fmt.Formatter", "Formatter", "fmt", null); + Stringer = $pkg.Stringer = $newType(8, $kindInterface, "fmt.Stringer", "Stringer", "fmt", null); + GoStringer = $pkg.GoStringer = $newType(8, $kindInterface, "fmt.GoStringer", "GoStringer", "fmt", null); + buffer = $pkg.buffer = $newType(12, $kindSlice, "fmt.buffer", "buffer", "fmt", null); + pp = $pkg.pp = $newType(0, $kindStruct, "fmt.pp", "pp", "fmt", function(n_, panicking_, erroring_, buf_, arg_, value_, reordered_, goodArgNum_, runeBuf_, fmt_) { + this.$val = this; + if (arguments.length === 0) { + this.n = 0; + this.panicking = false; + this.erroring = false; + this.buf = buffer.nil; + this.arg = $ifaceNil; + this.value = new reflect.Value.ptr(ptrType.nil, 0, 0); + this.reordered = false; + this.goodArgNum = false; + this.runeBuf = arrayType.zero(); + this.fmt = new fmt.ptr(arrayType$1.zero(), ptrType$1.nil, 0, 0, new fmtFlags.ptr(false, false, false, false, false, false, false, false, false, false, false)); + return; + } + this.n = n_; + this.panicking = panicking_; + this.erroring = erroring_; + this.buf = buf_; + this.arg = arg_; + this.value = value_; + this.reordered = reordered_; + this.goodArgNum = goodArgNum_; + this.runeBuf = runeBuf_; + this.fmt = fmt_; + }); + runeUnreader = $pkg.runeUnreader = $newType(8, $kindInterface, "fmt.runeUnreader", "runeUnreader", "fmt", null); + scanError = $pkg.scanError = $newType(0, $kindStruct, "fmt.scanError", "scanError", "fmt", function(err_) { + this.$val = this; + if (arguments.length === 0) { + this.err = $ifaceNil; + return; + } + this.err = err_; + }); + ss = $pkg.ss = $newType(0, $kindStruct, "fmt.ss", "ss", "fmt", function(rr_, buf_, peekRune_, prevRune_, count_, atEOF_, ssave_) { + this.$val = this; + if (arguments.length === 0) { + this.rr = $ifaceNil; + this.buf = buffer.nil; + this.peekRune = 0; + this.prevRune = 0; + this.count = 0; + this.atEOF = false; + this.ssave = new ssave.ptr(false, false, false, 0, 0, 0); + return; + } + this.rr = rr_; + this.buf = buf_; + this.peekRune = peekRune_; + this.prevRune = prevRune_; + this.count = count_; + this.atEOF = atEOF_; + this.ssave = ssave_; + }); + ssave = $pkg.ssave = $newType(0, $kindStruct, "fmt.ssave", "ssave", "fmt", 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($Uint8); + sliceType$1 = $sliceType($emptyInterface); + ptrType = $ptrType(reflect.rtype); + arrayType = $arrayType($Uint8, 4); + arrayType$1 = $arrayType($Uint8, 65); + ptrType$1 = $ptrType(buffer); + arrayType$2 = $arrayType($Uint16, 2); + sliceType$2 = $sliceType(arrayType$2); + ptrType$2 = $ptrType(pp); + ptrType$5 = $ptrType(ss); + ptrType$25 = $ptrType(fmt); + funcType = $funcType([$Int32], [$Bool], false); + init = function() { + var $ptr, i; + i = 0; + while (true) { + if (!(i < 65)) { break; } + ((i < 0 || i >= padZeroBytes.$length) ? $throwRuntimeError("index out of range") : padZeroBytes.$array[padZeroBytes.$offset + i] = 48); + ((i < 0 || i >= padSpaceBytes.$length) ? $throwRuntimeError("index out of range") : padSpaceBytes.$array[padSpaceBytes.$offset + i] = 32); + i = i + (1) >> 0; + } + }; + fmt.ptr.prototype.clearflags = function() { + var $ptr, f; + f = this; + fmtFlags.copy(f.fmtFlags, new fmtFlags.ptr(false, false, false, false, false, false, false, false, false, false, false)); + }; + fmt.prototype.clearflags = function() { return this.$val.clearflags(); }; + fmt.ptr.prototype.init = function(buf) { + var $ptr, buf, f; + f = this; + f.buf = buf; + f.clearflags(); + }; + fmt.prototype.init = function(buf) { return this.$val.init(buf); }; + fmt.ptr.prototype.computePadding = function(width) { + var $ptr, _tmp, _tmp$1, _tmp$2, _tmp$3, _tmp$4, _tmp$5, _tmp$6, _tmp$7, _tmp$8, f, left, leftWidth, padding, rightWidth, w, width; + padding = sliceType.nil; + leftWidth = 0; + rightWidth = 0; + f = this; + left = !f.fmtFlags.minus; + w = f.wid; + if (w < 0) { + left = false; + w = -w; + } + w = w - (width) >> 0; + if (w > 0) { + if (left && f.fmtFlags.zero) { + _tmp = padZeroBytes; + _tmp$1 = w; + _tmp$2 = 0; + padding = _tmp; + leftWidth = _tmp$1; + rightWidth = _tmp$2; + return [padding, leftWidth, rightWidth]; + } + if (left) { + _tmp$3 = padSpaceBytes; + _tmp$4 = w; + _tmp$5 = 0; + padding = _tmp$3; + leftWidth = _tmp$4; + rightWidth = _tmp$5; + return [padding, leftWidth, rightWidth]; + } else { + _tmp$6 = padSpaceBytes; + _tmp$7 = 0; + _tmp$8 = w; + padding = _tmp$6; + leftWidth = _tmp$7; + rightWidth = _tmp$8; + return [padding, leftWidth, rightWidth]; + } + } + return [padding, leftWidth, rightWidth]; + }; + fmt.prototype.computePadding = function(width) { return this.$val.computePadding(width); }; + fmt.ptr.prototype.writePadding = function(n, padding) { + var $ptr, f, m, n, padding; + f = this; + while (true) { + if (!(n > 0)) { break; } + m = n; + if (m > 65) { + m = 65; + } + f.buf.Write($subslice(padding, 0, m)); + n = n - (m) >> 0; + } + }; + fmt.prototype.writePadding = function(n, padding) { return this.$val.writePadding(n, padding); }; + fmt.ptr.prototype.pad = function(b) { + var $ptr, _tuple, b, f, left, padding, right; + f = this; + if (!f.fmtFlags.widPresent || (f.wid === 0)) { + f.buf.Write(b); + return; + } + _tuple = f.computePadding(utf8.RuneCount(b)); + padding = _tuple[0]; + left = _tuple[1]; + right = _tuple[2]; + if (left > 0) { + f.writePadding(left, padding); + } + f.buf.Write(b); + if (right > 0) { + f.writePadding(right, padding); + } + }; + fmt.prototype.pad = function(b) { return this.$val.pad(b); }; + fmt.ptr.prototype.padString = function(s) { + var $ptr, _tuple, f, left, padding, right, s; + f = this; + if (!f.fmtFlags.widPresent || (f.wid === 0)) { + f.buf.WriteString(s); + return; + } + _tuple = f.computePadding(utf8.RuneCountInString(s)); + padding = _tuple[0]; + left = _tuple[1]; + right = _tuple[2]; + if (left > 0) { + f.writePadding(left, padding); + } + f.buf.WriteString(s); + if (right > 0) { + f.writePadding(right, padding); + } + }; + fmt.prototype.padString = function(s) { return this.$val.padString(s); }; + fmt.ptr.prototype.fmt_boolean = function(v) { + var $ptr, f, v; + f = this; + if (v) { + f.pad(trueBytes); + } else { + f.pad(falseBytes); + } + }; + fmt.prototype.fmt_boolean = function(v) { return this.$val.fmt_boolean(v); }; + fmt.ptr.prototype.integer = function(a, base, signedness, digits) { + var $ptr, _1, _2, a, base, buf, digits, f, i, j, negative, next, prec, runeWidth, signedness, ua, width, width$1, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9; + f = this; + if (f.fmtFlags.precPresent && (f.prec === 0) && (a.$high === 0 && a.$low === 0)) { + return; + } + negative = signedness && (a.$high < 0 || (a.$high === 0 && a.$low < 0)); + if (negative) { + a = new $Int64(-a.$high, -a.$low); + } + buf = $subslice(new sliceType(f.intbuf), 0); + if (f.fmtFlags.widPresent || f.fmtFlags.precPresent || f.fmtFlags.plus || f.fmtFlags.space) { + width = f.wid + f.prec >> 0; + if ((base.$high === 0 && base.$low === 16) && f.fmtFlags.sharp) { + width = width + (2) >> 0; + } + if (f.fmtFlags.unicode) { + width = width + (2) >> 0; + if (f.fmtFlags.uniQuote) { + width = width + (7) >> 0; + } + } + if (negative || f.fmtFlags.plus || f.fmtFlags.space) { + width = width + (1) >> 0; + } + if (width > 65) { + buf = $makeSlice(sliceType, width); + } + } + prec = 0; + if (f.fmtFlags.precPresent) { + prec = f.prec; + f.fmtFlags.zero = false; + } else if (f.fmtFlags.zero && f.fmtFlags.widPresent && !f.fmtFlags.minus && f.wid > 0) { + prec = f.wid; + if (negative || f.fmtFlags.plus || f.fmtFlags.space) { + prec = prec - (1) >> 0; + } + } + i = buf.$length; + ua = new $Uint64(a.$high, a.$low); + _1 = base; + if ((x = new $Uint64(0, 10), (_1.$high === x.$high && _1.$low === x.$low))) { + while (true) { + if (!((ua.$high > 0 || (ua.$high === 0 && ua.$low >= 10)))) { break; } + i = i - (1) >> 0; + next = $div64(ua, new $Uint64(0, 10), false); + ((i < 0 || i >= buf.$length) ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + i] = ((x$4 = new $Uint64(0 + ua.$high, 48 + ua.$low), x$5 = $mul64(next, new $Uint64(0, 10)), new $Uint64(x$4.$high - x$5.$high, x$4.$low - x$5.$low)).$low << 24 >>> 24)); + ua = next; + } + } else if ((x$1 = new $Uint64(0, 16), (_1.$high === x$1.$high && _1.$low === x$1.$low))) { + while (true) { + if (!((ua.$high > 0 || (ua.$high === 0 && ua.$low >= 16)))) { break; } + i = i - (1) >> 0; + ((i < 0 || i >= buf.$length) ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + i] = digits.charCodeAt($flatten64(new $Uint64(ua.$high & 0, (ua.$low & 15) >>> 0)))); + ua = $shiftRightUint64(ua, (4)); + } + } else if ((x$2 = new $Uint64(0, 8), (_1.$high === x$2.$high && _1.$low === x$2.$low))) { + while (true) { + if (!((ua.$high > 0 || (ua.$high === 0 && ua.$low >= 8)))) { break; } + i = i - (1) >> 0; + ((i < 0 || i >= buf.$length) ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + i] = ((x$6 = new $Uint64(ua.$high & 0, (ua.$low & 7) >>> 0), new $Uint64(0 + x$6.$high, 48 + x$6.$low)).$low << 24 >>> 24)); + ua = $shiftRightUint64(ua, (3)); + } + } else if ((x$3 = new $Uint64(0, 2), (_1.$high === x$3.$high && _1.$low === x$3.$low))) { + while (true) { + if (!((ua.$high > 0 || (ua.$high === 0 && ua.$low >= 2)))) { break; } + i = i - (1) >> 0; + ((i < 0 || i >= buf.$length) ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + i] = ((x$7 = new $Uint64(ua.$high & 0, (ua.$low & 1) >>> 0), new $Uint64(0 + x$7.$high, 48 + x$7.$low)).$low << 24 >>> 24)); + ua = $shiftRightUint64(ua, (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") : buf.$array[buf.$offset + i] = digits.charCodeAt($flatten64(ua))); + 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") : buf.$array[buf.$offset + i] = 48); + } + if (f.fmtFlags.sharp) { + _2 = base; + if ((x$8 = new $Uint64(0, 8), (_2.$high === x$8.$high && _2.$low === x$8.$low))) { + if (!((((i < 0 || i >= buf.$length) ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + i]) === 48))) { + i = i - (1) >> 0; + ((i < 0 || i >= buf.$length) ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + i] = 48); + } + } else if ((x$9 = new $Uint64(0, 16), (_2.$high === x$9.$high && _2.$low === x$9.$low))) { + i = i - (1) >> 0; + ((i < 0 || i >= buf.$length) ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + i] = ((120 + digits.charCodeAt(10) << 24 >>> 24) - 97 << 24 >>> 24)); + i = i - (1) >> 0; + ((i < 0 || i >= buf.$length) ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + i] = 48); + } + } + if (f.fmtFlags.unicode) { + i = i - (1) >> 0; + ((i < 0 || i >= buf.$length) ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + i] = 43); + i = i - (1) >> 0; + ((i < 0 || i >= buf.$length) ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + i] = 85); + } + if (negative) { + i = i - (1) >> 0; + ((i < 0 || i >= buf.$length) ? $throwRuntimeError("index out of range") : 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") : 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") : buf.$array[buf.$offset + i] = 32); + } + if (f.fmtFlags.unicode && f.fmtFlags.uniQuote && (a.$high > 0 || (a.$high === 0 && a.$low >= 0)) && (a.$high < 0 || (a.$high === 0 && a.$low <= 1114111)) && strconv.IsPrint(((a.$low + ((a.$high >> 31) * 4294967296)) >> 0))) { + runeWidth = utf8.RuneLen(((a.$low + ((a.$high >> 31) * 4294967296)) >> 0)); + width$1 = (2 + runeWidth >> 0) + 1 >> 0; + $copySlice($subslice(buf, (i - width$1 >> 0)), $subslice(buf, i)); + i = i - (width$1) >> 0; + j = buf.$length - width$1 >> 0; + ((j < 0 || j >= buf.$length) ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + j] = 32); + j = j + (1) >> 0; + ((j < 0 || j >= buf.$length) ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + j] = 39); + j = j + (1) >> 0; + utf8.EncodeRune($subslice(buf, j), ((a.$low + ((a.$high >> 31) * 4294967296)) >> 0)); + j = j + (runeWidth) >> 0; + ((j < 0 || j >= buf.$length) ? $throwRuntimeError("index out of range") : buf.$array[buf.$offset + j] = 39); + } + f.pad($subslice(buf, i)); + }; + fmt.prototype.integer = function(a, base, signedness, digits) { return this.$val.integer(a, base, signedness, digits); }; + fmt.ptr.prototype.truncate = function(s) { + var $ptr, _i, _ref, _rune, f, i, n, s; + f = this; + if (f.fmtFlags.precPresent && f.prec < utf8.RuneCountInString(s)) { + n = f.prec; + _ref = s; + _i = 0; + while (true) { + if (!(_i < _ref.length)) { break; } + _rune = $decodeRune(_ref, _i); + i = _i; + if (n === 0) { + s = s.substring(0, i); + break; + } + n = n - (1) >> 0; + _i += _rune[1]; + } + } + return s; + }; + fmt.prototype.truncate = function(s) { return this.$val.truncate(s); }; + fmt.ptr.prototype.fmt_s = function(s) { + var $ptr, f, s; + f = this; + s = f.truncate(s); + f.padString(s); + }; + fmt.prototype.fmt_s = function(s) { return this.$val.fmt_s(s); }; + fmt.ptr.prototype.fmt_sbx = function(s, b, digits) { + var $ptr, b, buf, c, digits, f, i, n, s, x; + f = this; + n = b.$length; + if (b === sliceType.nil) { + n = s.length; + } + x = (digits.charCodeAt(10) - 97 << 24 >>> 24) + 120 << 24 >>> 24; + buf = sliceType.nil; + i = 0; + while (true) { + if (!(i < n)) { break; } + if (i > 0 && f.fmtFlags.space) { + buf = $append(buf, 32); + } + if (f.fmtFlags.sharp && (f.fmtFlags.space || (i === 0))) { + buf = $append(buf, 48, x); + } + c = 0; + if (b === sliceType.nil) { + c = s.charCodeAt(i); + } else { + c = ((i < 0 || i >= b.$length) ? $throwRuntimeError("index out of range") : b.$array[b.$offset + i]); + } + buf = $append(buf, digits.charCodeAt((c >>> 4 << 24 >>> 24)), digits.charCodeAt(((c & 15) >>> 0))); + i = i + (1) >> 0; + } + f.pad(buf); + }; + fmt.prototype.fmt_sbx = function(s, b, digits) { return this.$val.fmt_sbx(s, b, digits); }; + fmt.ptr.prototype.fmt_sx = function(s, digits) { + var $ptr, digits, f, s; + f = this; + if (f.fmtFlags.precPresent && f.prec < s.length) { + s = s.substring(0, f.prec); + } + f.fmt_sbx(s, sliceType.nil, digits); + }; + fmt.prototype.fmt_sx = function(s, digits) { return this.$val.fmt_sx(s, digits); }; + fmt.ptr.prototype.fmt_bx = function(b, digits) { + var $ptr, b, digits, f; + f = this; + if (f.fmtFlags.precPresent && f.prec < b.$length) { + b = $subslice(b, 0, f.prec); + } + f.fmt_sbx("", b, digits); + }; + fmt.prototype.fmt_bx = function(b, digits) { return this.$val.fmt_bx(b, digits); }; + fmt.ptr.prototype.fmt_q = function(s) { + var $ptr, f, quoted, s; + f = this; + s = f.truncate(s); + quoted = ""; + if (f.fmtFlags.sharp && strconv.CanBackquote(s)) { + quoted = "`" + s + "`"; + } else { + if (f.fmtFlags.plus) { + quoted = strconv.QuoteToASCII(s); + } else { + quoted = strconv.Quote(s); + } + } + f.padString(quoted); + }; + fmt.prototype.fmt_q = function(s) { return this.$val.fmt_q(s); }; + fmt.ptr.prototype.fmt_qc = function(c) { + var $ptr, c, f, quoted; + f = this; + quoted = sliceType.nil; + if (f.fmtFlags.plus) { + quoted = strconv.AppendQuoteRuneToASCII($subslice(new sliceType(f.intbuf), 0, 0), ((c.$low + ((c.$high >> 31) * 4294967296)) >> 0)); + } else { + quoted = strconv.AppendQuoteRune($subslice(new sliceType(f.intbuf), 0, 0), ((c.$low + ((c.$high >> 31) * 4294967296)) >> 0)); + } + f.pad(quoted); + }; + fmt.prototype.fmt_qc = function(c) { return this.$val.fmt_qc(c); }; + doPrec = function(f, def) { + var $ptr, def, f; + if (f.fmtFlags.precPresent) { + return f.prec; + } + return def; + }; + fmt.ptr.prototype.formatFloat = function(v, verb, prec, n) { + var $ptr, f, n, num, prec, v, verb, $deferred; + /* */ var $err = null; try { $deferred = []; $deferred.index = $curGoroutine.deferStack.length; $curGoroutine.deferStack.push($deferred); + f = this; + num = strconv.AppendFloat($subslice(new sliceType(f.intbuf), 0, 1), v, verb, prec, n); + if (((1 >= num.$length ? $throwRuntimeError("index out of range") : num.$array[num.$offset + 1]) === 45) || ((1 >= num.$length ? $throwRuntimeError("index out of range") : num.$array[num.$offset + 1]) === 43)) { + num = $subslice(num, 1); + } else { + (0 >= num.$length ? $throwRuntimeError("index out of range") : num.$array[num.$offset + 0] = 43); + } + if (math.IsInf(v, 0)) { + if (f.fmtFlags.zero) { + $deferred.push([(function() { + var $ptr; + f.fmtFlags.zero = true; + }), []]); + f.fmtFlags.zero = false; + } + } + if (f.fmtFlags.zero && f.fmtFlags.widPresent && f.wid > num.$length) { + if (f.fmtFlags.space && v >= 0) { + f.buf.WriteByte(32); + f.wid = f.wid - (1) >> 0; + } else if (f.fmtFlags.plus || v < 0) { + f.buf.WriteByte((0 >= num.$length ? $throwRuntimeError("index out of range") : num.$array[num.$offset + 0])); + f.wid = f.wid - (1) >> 0; + } + f.pad($subslice(num, 1)); + return; + } + if (f.fmtFlags.space && ((0 >= num.$length ? $throwRuntimeError("index out of range") : num.$array[num.$offset + 0]) === 43)) { + (0 >= num.$length ? $throwRuntimeError("index out of range") : num.$array[num.$offset + 0] = 32); + f.pad(num); + return; + } + if (f.fmtFlags.plus || ((0 >= num.$length ? $throwRuntimeError("index out of range") : num.$array[num.$offset + 0]) === 45) || math.IsInf(v, 0)) { + f.pad(num); + return; + } + f.pad($subslice(num, 1)); + /* */ } catch(err) { $err = err; } finally { $callDeferred($deferred, $err); } + }; + fmt.prototype.formatFloat = function(v, verb, prec, n) { return this.$val.formatFloat(v, verb, prec, n); }; + fmt.ptr.prototype.fmt_e64 = function(v) { + var $ptr, f, v; + f = this; + f.formatFloat(v, 101, doPrec(f, 6), 64); + }; + fmt.prototype.fmt_e64 = function(v) { return this.$val.fmt_e64(v); }; + fmt.ptr.prototype.fmt_E64 = function(v) { + var $ptr, f, v; + f = this; + f.formatFloat(v, 69, doPrec(f, 6), 64); + }; + fmt.prototype.fmt_E64 = function(v) { return this.$val.fmt_E64(v); }; + fmt.ptr.prototype.fmt_f64 = function(v) { + var $ptr, f, v; + f = this; + f.formatFloat(v, 102, doPrec(f, 6), 64); + }; + fmt.prototype.fmt_f64 = function(v) { return this.$val.fmt_f64(v); }; + fmt.ptr.prototype.fmt_g64 = function(v) { + var $ptr, f, v; + f = this; + f.formatFloat(v, 103, doPrec(f, -1), 64); + }; + fmt.prototype.fmt_g64 = function(v) { return this.$val.fmt_g64(v); }; + fmt.ptr.prototype.fmt_G64 = function(v) { + var $ptr, f, v; + f = this; + f.formatFloat(v, 71, doPrec(f, -1), 64); + }; + fmt.prototype.fmt_G64 = function(v) { return this.$val.fmt_G64(v); }; + fmt.ptr.prototype.fmt_fb64 = function(v) { + var $ptr, f, v; + f = this; + f.formatFloat(v, 98, 0, 64); + }; + fmt.prototype.fmt_fb64 = function(v) { return this.$val.fmt_fb64(v); }; + fmt.ptr.prototype.fmt_e32 = function(v) { + var $ptr, f, v; + f = this; + f.formatFloat(v, 101, doPrec(f, 6), 32); + }; + fmt.prototype.fmt_e32 = function(v) { return this.$val.fmt_e32(v); }; + fmt.ptr.prototype.fmt_E32 = function(v) { + var $ptr, f, v; + f = this; + f.formatFloat(v, 69, doPrec(f, 6), 32); + }; + fmt.prototype.fmt_E32 = function(v) { return this.$val.fmt_E32(v); }; + fmt.ptr.prototype.fmt_f32 = function(v) { + var $ptr, f, v; + f = this; + f.formatFloat(v, 102, doPrec(f, 6), 32); + }; + fmt.prototype.fmt_f32 = function(v) { return this.$val.fmt_f32(v); }; + fmt.ptr.prototype.fmt_g32 = function(v) { + var $ptr, f, v; + f = this; + f.formatFloat(v, 103, doPrec(f, -1), 32); + }; + fmt.prototype.fmt_g32 = function(v) { return this.$val.fmt_g32(v); }; + fmt.ptr.prototype.fmt_G32 = function(v) { + var $ptr, f, v; + f = this; + f.formatFloat(v, 71, doPrec(f, -1), 32); + }; + fmt.prototype.fmt_G32 = function(v) { return this.$val.fmt_G32(v); }; + fmt.ptr.prototype.fmt_fb32 = function(v) { + var $ptr, f, v; + f = this; + f.formatFloat(v, 98, 0, 32); + }; + fmt.prototype.fmt_fb32 = function(v) { return this.$val.fmt_fb32(v); }; + fmt.ptr.prototype.fmt_c64 = function(v, verb) { + var $ptr, f, v, verb; + f = this; + f.fmt_complex(v.$real, v.$imag, 32, verb); + }; + fmt.prototype.fmt_c64 = function(v, verb) { return this.$val.fmt_c64(v, verb); }; + fmt.ptr.prototype.fmt_c128 = function(v, verb) { + var $ptr, f, v, verb; + f = this; + f.fmt_complex(v.$real, v.$imag, 64, verb); + }; + fmt.prototype.fmt_c128 = function(v, verb) { return this.$val.fmt_c128(v, verb); }; + fmt.ptr.prototype.fmt_complex = function(r, j, size, verb) { + var $ptr, _3, f, i, j, oldPlus, oldSpace, oldWid, r, size, verb; + f = this; + f.buf.WriteByte(40); + oldPlus = f.fmtFlags.plus; + oldSpace = f.fmtFlags.space; + oldWid = f.wid; + i = 0; + while (true) { + _3 = verb; + if (_3 === (98)) { + f.formatFloat(r, 98, 0, size); + } else if (_3 === (101)) { + f.formatFloat(r, 101, doPrec(f, 6), size); + } else if (_3 === (69)) { + f.formatFloat(r, 69, doPrec(f, 6), size); + } else if ((_3 === (102)) || (_3 === (70))) { + f.formatFloat(r, 102, doPrec(f, 6), size); + } else if (_3 === (103)) { + f.formatFloat(r, 103, doPrec(f, -1), size); + } else if (_3 === (71)) { + f.formatFloat(r, 71, doPrec(f, -1), size); + } + if (!((i === 0))) { + break; + } + f.fmtFlags.plus = true; + f.fmtFlags.space = false; + f.wid = oldWid; + r = j; + i = i + (1) >> 0; + } + f.fmtFlags.space = oldSpace; + f.fmtFlags.plus = oldPlus; + f.wid = oldWid; + f.buf.Write(irparenBytes); + }; + fmt.prototype.fmt_complex = function(r, j, size, verb) { return this.$val.fmt_complex(r, j, size, verb); }; + $ptrType(buffer).prototype.Write = function(p) { + var $ptr, _tmp, _tmp$1, b, err, n, p; + n = 0; + err = $ifaceNil; + b = this; + b.$set($appendSlice(b.$get(), p)); + _tmp = p.$length; + _tmp$1 = $ifaceNil; + n = _tmp; + err = _tmp$1; + return [n, err]; + }; + $ptrType(buffer).prototype.WriteString = function(s) { + var $ptr, _tmp, _tmp$1, b, err, n, s; + n = 0; + err = $ifaceNil; + b = this; + b.$set($appendSlice(b.$get(), s)); + _tmp = s.length; + _tmp$1 = $ifaceNil; + n = _tmp; + err = _tmp$1; + return [n, err]; + }; + $ptrType(buffer).prototype.WriteByte = function(c) { + var $ptr, b, c; + b = this; + b.$set($append(b.$get(), c)); + return $ifaceNil; + }; + $ptrType(buffer).prototype.WriteRune = function(r) { + var $ptr, b, bp, n, r, w, x; + bp = this; + if (r < 128) { + bp.$set($append(bp.$get(), (r << 24 >>> 24))); + return $ifaceNil; + } + 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(x.$array), x.$offset, x.$offset + x.$length)), r); + bp.$set($subslice(b, 0, (n + w >> 0))); + return $ifaceNil; + }; + newPrinter = function() { + var $ptr, _r$2, p, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; p = $f.p; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r$2 = ppFree.Get(); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + p = $assertType(_r$2, 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)))); + return p; + /* */ } return; } if ($f === undefined) { $f = { $blk: newPrinter }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f.p = p; $f.$s = $s; $f.$r = $r; return $f; + }; + pp.ptr.prototype.free = function() { + var $ptr, p; + p = this; + if (p.buf.$capacity > 1024) { + 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 $ptr, _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 $ptr, _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 $ptr, _1, b, p; + p = this; + _1 = b; + if (_1 === (45)) { + return p.fmt.fmtFlags.minus; + } else if (_1 === (43)) { + return p.fmt.fmtFlags.plus; + } else if (_1 === (35)) { + return p.fmt.fmtFlags.sharp; + } 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.add = function(c) { + var $ptr, c, p; + p = this; + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteRune(c); + }; + pp.prototype.add = function(c) { return this.$val.add(c); }; + pp.ptr.prototype.Write = function(b) { + var $ptr, _tuple, b, err, p, ret; + ret = 0; + err = $ifaceNil; + p = this; + _tuple = (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).Write(b); + ret = _tuple[0]; + err = _tuple[1]; + return [ret, err]; + }; + pp.prototype.Write = function(b) { return this.$val.Write(b); }; + Fprintf = function(w, format, a) { + var $ptr, _r$2, _r$3, _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; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; _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$2 = newPrinter(); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + p = _r$2; + $r = p.doPrintf(format, a); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + _r$3 = w.Write((x = p.buf, $subslice(new sliceType(x.$array), x.$offset, x.$offset + x.$length))); /* */ $s = 3; case 3: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _tuple = _r$3; + n = _tuple[0]; + err = _tuple[1]; + p.free(); + return [n, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Fprintf }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $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 $ptr, _r$2, a, format, p, s, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; 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$2 = newPrinter(); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + p = _r$2; + $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(); + return s; + /* */ } return; } if ($f === undefined) { $f = { $blk: Sprintf }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $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 $ptr, _r$2, _r$3, a, format, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; a = $f.a; format = $f.format; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r$2 = Sprintf(format, a); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _r$3 = errors.New(_r$2); /* */ $s = 2; case 2: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + /* */ $s = 3; case 3: + return _r$3; + /* */ } return; } if ($f === undefined) { $f = { $blk: Errorf }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $f.a = a; $f.format = format; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.Errorf = Errorf; + Fprint = function(w, a) { + var $ptr, _r$2, _r$3, _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; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; _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$2 = newPrinter(); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + p = _r$2; + $r = p.doPrint(a, false, false); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + _r$3 = w.Write((x = p.buf, $subslice(new sliceType(x.$array), x.$offset, x.$offset + x.$length))); /* */ $s = 3; case 3: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _tuple = _r$3; + n = _tuple[0]; + err = _tuple[1]; + p.free(); + return [n, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Fprint }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $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; + Fprintln = function(w, a) { + var $ptr, _r$2, _r$3, _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; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; _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$2 = newPrinter(); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + p = _r$2; + $r = p.doPrint(a, true, true); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + _r$3 = w.Write((x = p.buf, $subslice(new sliceType(x.$array), x.$offset, x.$offset + x.$length))); /* */ $s = 3; case 3: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _tuple = _r$3; + n = _tuple[0]; + err = _tuple[1]; + p.free(); + return [n, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Fprintln }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $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.Fprintln = Fprintln; + getField = function(v, i) { + var $ptr, _r$2, _r$3, i, v, val, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; i = $f.i; v = $f.v; val = $f.val; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = v; + _r$2 = v.Field(i); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + val = _r$2; + /* */ if ((val.Kind() === 20) && !val.IsNil()) { $s = 2; continue; } + /* */ $s = 3; continue; + /* if ((val.Kind() === 20) && !val.IsNil()) { */ case 2: + _r$3 = val.Elem(); /* */ $s = 4; case 4: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + val = _r$3; + /* } */ case 3: + return val; + /* */ } return; } if ($f === undefined) { $f = { $blk: getField }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $f.i = i; $f.v = v; $f.val = val; $f.$s = $s; $f.$r = $r; return $f; + }; + tooLarge = function(x) { + var $ptr, x; + return x > 1000000 || x < -1000000; + }; + parsenum = function(s, start, end) { + var $ptr, _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 $ptr, _r$2, _r$3, p, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; p = $f.p; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = v; + p = this; + if (!v.IsValid()) { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).Write(nilAngleBytes); + 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$2 = v.Type().String(); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _r$3 = (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 = 2; case 2: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _r$3; + (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; case -1: } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.unknownType }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $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 $ptr, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, p, verb, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _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; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + p = this; + p.erroring = true; + p.add(37); + p.add(33); + p.add(verb); + p.add(40); + /* */ if (!($interfaceIsEqual(p.arg, $ifaceNil))) { $s = 2; continue; } + /* */ if (p.value.IsValid()) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (!($interfaceIsEqual(p.arg, $ifaceNil))) { */ case 2: + _r$2 = reflect.TypeOf(p.arg).String(); /* */ $s = 6; case 6: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _r$3 = (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 = 7; case 7: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _r$3; + p.add(61); + _r$4 = p.printArg(p.arg, 118, 0); /* */ $s = 8; case 8: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + _r$4; + $s = 5; continue; + /* } else if (p.value.IsValid()) { */ case 3: + _r$5 = p.value.Type().String(); /* */ $s = 9; case 9: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + _r$6 = (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 = 10; case 10: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + _r$6; + p.add(61); + _r$7 = p.printValue(p.value, 118, 0); /* */ $s = 11; case 11: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } + _r$7; + $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))).Write(nilAngleBytes); + /* } */ case 5: + case 1: + p.add(41); + p.erroring = false; + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.badVerb }; } $f.$ptr = $ptr; $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.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 $ptr, _2, p, v, verb, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _2 = $f._2; p = $f.p; v = $f.v; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + p = this; + _2 = verb; + /* */ if ((_2 === (116)) || (_2 === (118))) { $s = 2; continue; } + /* */ $s = 3; continue; + /* if ((_2 === (116)) || (_2 === (118))) { */ case 2: + p.fmt.fmt_boolean(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; case -1: } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.fmtBool }; } $f.$ptr = $ptr; $f._2 = _2; $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.fmtC = function(c) { + var $ptr, c, p, r, w, x; + p = this; + r = ((c.$low + ((c.$high >> 31) * 4294967296)) >> 0); + if (!((x = new $Int64(0, r), (x.$high === c.$high && x.$low === c.$low)))) { + r = 65533; + } + w = utf8.EncodeRune($subslice(new sliceType(p.runeBuf), 0, 4), r); + p.fmt.pad($subslice(new sliceType(p.runeBuf), 0, w)); + }; + pp.prototype.fmtC = function(c) { return this.$val.fmtC(c); }; + pp.ptr.prototype.fmtInt64 = function(v, verb) { + var $ptr, _3, p, v, verb, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _3 = $f._3; p = $f.p; v = $f.v; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + p = this; + _3 = verb; + /* */ if (_3 === (98)) { $s = 2; continue; } + /* */ if (_3 === (99)) { $s = 3; continue; } + /* */ if ((_3 === (100)) || (_3 === (118))) { $s = 4; continue; } + /* */ if (_3 === (111)) { $s = 5; continue; } + /* */ if (_3 === (113)) { $s = 6; continue; } + /* */ if (_3 === (120)) { $s = 7; continue; } + /* */ if (_3 === (85)) { $s = 8; continue; } + /* */ if (_3 === (88)) { $s = 9; continue; } + /* */ $s = 10; continue; + /* if (_3 === (98)) { */ case 2: + p.fmt.integer(v, new $Uint64(0, 2), true, "0123456789abcdef"); + $s = 11; continue; + /* } else if (_3 === (99)) { */ case 3: + p.fmtC(v); + $s = 11; continue; + /* } else if ((_3 === (100)) || (_3 === (118))) { */ case 4: + p.fmt.integer(v, new $Uint64(0, 10), true, "0123456789abcdef"); + $s = 11; continue; + /* } else if (_3 === (111)) { */ case 5: + p.fmt.integer(v, new $Uint64(0, 8), true, "0123456789abcdef"); + $s = 11; continue; + /* } else if (_3 === (113)) { */ case 6: + /* */ if ((0 < v.$high || (0 === v.$high && 0 <= v.$low)) && (v.$high < 0 || (v.$high === 0 && v.$low <= 1114111))) { $s = 12; continue; } + /* */ $s = 13; continue; + /* if ((0 < v.$high || (0 === v.$high && 0 <= v.$low)) && (v.$high < 0 || (v.$high === 0 && v.$low <= 1114111))) { */ case 12: + p.fmt.fmt_qc(v); + $s = 14; continue; + /* } else { */ case 13: + $r = p.badVerb(verb); /* */ $s = 15; case 15: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 14: + $s = 11; continue; + /* } else if (_3 === (120)) { */ case 7: + p.fmt.integer(v, new $Uint64(0, 16), true, "0123456789abcdef"); + $s = 11; continue; + /* } else if (_3 === (85)) { */ case 8: + p.fmtUnicode(v); + $s = 11; continue; + /* } else if (_3 === (88)) { */ case 9: + p.fmt.integer(v, new $Uint64(0, 16), true, "0123456789ABCDEF"); + $s = 11; continue; + /* } else { */ case 10: + $r = p.badVerb(verb); /* */ $s = 16; case 16: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 11: + case 1: + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.fmtInt64 }; } $f.$ptr = $ptr; $f._3 = _3; $f.p = p; $f.v = v; $f.verb = verb; $f.$s = $s; $f.$r = $r; return $f; + }; + pp.prototype.fmtInt64 = function(v, verb) { return this.$val.fmtInt64(v, verb); }; + pp.ptr.prototype.fmt0x64 = function(v, leading0x) { + var $ptr, leading0x, p, sharp, v; + p = this; + sharp = p.fmt.fmtFlags.sharp; + p.fmt.fmtFlags.sharp = leading0x; + p.fmt.integer(new $Int64(v.$high, v.$low), new $Uint64(0, 16), false, "0123456789abcdef"); + p.fmt.fmtFlags.sharp = sharp; + }; + pp.prototype.fmt0x64 = function(v, leading0x) { return this.$val.fmt0x64(v, leading0x); }; + pp.ptr.prototype.fmtUnicode = function(v) { + var $ptr, p, prec, precPresent, sharp, v; + p = this; + precPresent = p.fmt.fmtFlags.precPresent; + sharp = p.fmt.fmtFlags.sharp; + p.fmt.fmtFlags.sharp = false; + prec = p.fmt.prec; + if (!precPresent) { + p.fmt.prec = 4; + p.fmt.fmtFlags.precPresent = true; + } + p.fmt.fmtFlags.unicode = true; + p.fmt.fmtFlags.uniQuote = sharp; + p.fmt.integer(v, new $Uint64(0, 16), false, "0123456789ABCDEF"); + p.fmt.fmtFlags.unicode = false; + p.fmt.fmtFlags.uniQuote = false; + p.fmt.prec = prec; + p.fmt.fmtFlags.precPresent = precPresent; + p.fmt.fmtFlags.sharp = sharp; + }; + pp.prototype.fmtUnicode = function(v) { return this.$val.fmtUnicode(v); }; + pp.ptr.prototype.fmtUint64 = function(v, verb) { + var $ptr, _4, p, v, verb, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _4 = $f._4; p = $f.p; v = $f.v; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + p = this; + _4 = verb; + /* */ if (_4 === (98)) { $s = 2; continue; } + /* */ if (_4 === (99)) { $s = 3; continue; } + /* */ if (_4 === (100)) { $s = 4; continue; } + /* */ if (_4 === (118)) { $s = 5; continue; } + /* */ if (_4 === (111)) { $s = 6; continue; } + /* */ if (_4 === (113)) { $s = 7; continue; } + /* */ if (_4 === (120)) { $s = 8; continue; } + /* */ if (_4 === (88)) { $s = 9; continue; } + /* */ if (_4 === (85)) { $s = 10; continue; } + /* */ $s = 11; continue; + /* if (_4 === (98)) { */ case 2: + p.fmt.integer(new $Int64(v.$high, v.$low), new $Uint64(0, 2), false, "0123456789abcdef"); + $s = 12; continue; + /* } else if (_4 === (99)) { */ case 3: + p.fmtC(new $Int64(v.$high, v.$low)); + $s = 12; continue; + /* } else if (_4 === (100)) { */ case 4: + p.fmt.integer(new $Int64(v.$high, v.$low), new $Uint64(0, 10), false, "0123456789abcdef"); + $s = 12; continue; + /* } else if (_4 === (118)) { */ case 5: + if (p.fmt.fmtFlags.sharpV) { + p.fmt0x64(v, true); + } else { + p.fmt.integer(new $Int64(v.$high, v.$low), new $Uint64(0, 10), false, "0123456789abcdef"); + } + $s = 12; continue; + /* } else if (_4 === (111)) { */ case 6: + p.fmt.integer(new $Int64(v.$high, v.$low), new $Uint64(0, 8), false, "0123456789abcdef"); + $s = 12; continue; + /* } else if (_4 === (113)) { */ case 7: + /* */ if ((0 < v.$high || (0 === v.$high && 0 <= v.$low)) && (v.$high < 0 || (v.$high === 0 && v.$low <= 1114111))) { $s = 13; continue; } + /* */ $s = 14; continue; + /* if ((0 < v.$high || (0 === v.$high && 0 <= v.$low)) && (v.$high < 0 || (v.$high === 0 && v.$low <= 1114111))) { */ case 13: + p.fmt.fmt_qc(new $Int64(v.$high, v.$low)); + $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 (_4 === (120)) { */ case 8: + p.fmt.integer(new $Int64(v.$high, v.$low), new $Uint64(0, 16), false, "0123456789abcdef"); + $s = 12; continue; + /* } else if (_4 === (88)) { */ case 9: + p.fmt.integer(new $Int64(v.$high, v.$low), new $Uint64(0, 16), false, "0123456789ABCDEF"); + $s = 12; continue; + /* } else if (_4 === (85)) { */ case 10: + p.fmtUnicode(new $Int64(v.$high, v.$low)); + $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; case -1: } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.fmtUint64 }; } $f.$ptr = $ptr; $f._4 = _4; $f.p = p; $f.v = v; $f.verb = verb; $f.$s = $s; $f.$r = $r; return $f; + }; + pp.prototype.fmtUint64 = function(v, verb) { return this.$val.fmtUint64(v, verb); }; + pp.ptr.prototype.fmtFloat32 = function(v, verb) { + var $ptr, _5, p, v, verb, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _5 = $f._5; p = $f.p; v = $f.v; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + p = this; + _5 = verb; + /* */ if (_5 === (98)) { $s = 2; continue; } + /* */ if (_5 === (101)) { $s = 3; continue; } + /* */ if (_5 === (69)) { $s = 4; continue; } + /* */ if ((_5 === (102)) || (_5 === (70))) { $s = 5; continue; } + /* */ if ((_5 === (103)) || (_5 === (118))) { $s = 6; continue; } + /* */ if (_5 === (71)) { $s = 7; continue; } + /* */ $s = 8; continue; + /* if (_5 === (98)) { */ case 2: + p.fmt.fmt_fb32(v); + $s = 9; continue; + /* } else if (_5 === (101)) { */ case 3: + p.fmt.fmt_e32(v); + $s = 9; continue; + /* } else if (_5 === (69)) { */ case 4: + p.fmt.fmt_E32(v); + $s = 9; continue; + /* } else if ((_5 === (102)) || (_5 === (70))) { */ case 5: + p.fmt.fmt_f32(v); + $s = 9; continue; + /* } else if ((_5 === (103)) || (_5 === (118))) { */ case 6: + p.fmt.fmt_g32(v); + $s = 9; continue; + /* } else if (_5 === (71)) { */ case 7: + p.fmt.fmt_G32(v); + $s = 9; continue; + /* } else { */ case 8: + $r = p.badVerb(verb); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 9: + case 1: + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.fmtFloat32 }; } $f.$ptr = $ptr; $f._5 = _5; $f.p = p; $f.v = v; $f.verb = verb; $f.$s = $s; $f.$r = $r; return $f; + }; + pp.prototype.fmtFloat32 = function(v, verb) { return this.$val.fmtFloat32(v, verb); }; + pp.ptr.prototype.fmtFloat64 = function(v, verb) { + var $ptr, _6, p, v, verb, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _6 = $f._6; p = $f.p; v = $f.v; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + p = this; + _6 = verb; + /* */ if (_6 === (98)) { $s = 2; continue; } + /* */ if (_6 === (101)) { $s = 3; continue; } + /* */ if (_6 === (69)) { $s = 4; continue; } + /* */ if ((_6 === (102)) || (_6 === (70))) { $s = 5; continue; } + /* */ if ((_6 === (103)) || (_6 === (118))) { $s = 6; continue; } + /* */ if (_6 === (71)) { $s = 7; continue; } + /* */ $s = 8; continue; + /* if (_6 === (98)) { */ case 2: + p.fmt.fmt_fb64(v); + $s = 9; continue; + /* } else if (_6 === (101)) { */ case 3: + p.fmt.fmt_e64(v); + $s = 9; continue; + /* } else if (_6 === (69)) { */ case 4: + p.fmt.fmt_E64(v); + $s = 9; continue; + /* } else if ((_6 === (102)) || (_6 === (70))) { */ case 5: + p.fmt.fmt_f64(v); + $s = 9; continue; + /* } else if ((_6 === (103)) || (_6 === (118))) { */ case 6: + p.fmt.fmt_g64(v); + $s = 9; continue; + /* } else if (_6 === (71)) { */ case 7: + p.fmt.fmt_G64(v); + $s = 9; continue; + /* } else { */ case 8: + $r = p.badVerb(verb); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 9: + case 1: + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.fmtFloat64 }; } $f.$ptr = $ptr; $f._6 = _6; $f.p = p; $f.v = v; $f.verb = verb; $f.$s = $s; $f.$r = $r; return $f; + }; + pp.prototype.fmtFloat64 = function(v, verb) { return this.$val.fmtFloat64(v, verb); }; + pp.ptr.prototype.fmtComplex64 = function(v, verb) { + var $ptr, _7, p, v, verb, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _7 = $f._7; p = $f.p; v = $f.v; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + p = this; + _7 = verb; + /* */ if ((_7 === (98)) || (_7 === (101)) || (_7 === (69)) || (_7 === (102)) || (_7 === (70)) || (_7 === (103)) || (_7 === (71))) { $s = 2; continue; } + /* */ if (_7 === (118)) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if ((_7 === (98)) || (_7 === (101)) || (_7 === (69)) || (_7 === (102)) || (_7 === (70)) || (_7 === (103)) || (_7 === (71))) { */ case 2: + p.fmt.fmt_c64(v, verb); + $s = 5; continue; + /* } else if (_7 === (118)) { */ case 3: + p.fmt.fmt_c64(v, 103); + $s = 5; continue; + /* } else { */ case 4: + $r = p.badVerb(verb); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 5: + case 1: + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.fmtComplex64 }; } $f.$ptr = $ptr; $f._7 = _7; $f.p = p; $f.v = v; $f.verb = verb; $f.$s = $s; $f.$r = $r; return $f; + }; + pp.prototype.fmtComplex64 = function(v, verb) { return this.$val.fmtComplex64(v, verb); }; + pp.ptr.prototype.fmtComplex128 = function(v, verb) { + var $ptr, _8, p, v, verb, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _8 = $f._8; p = $f.p; v = $f.v; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + p = this; + _8 = verb; + /* */ if ((_8 === (98)) || (_8 === (101)) || (_8 === (69)) || (_8 === (102)) || (_8 === (70)) || (_8 === (103)) || (_8 === (71))) { $s = 2; continue; } + /* */ if (_8 === (118)) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if ((_8 === (98)) || (_8 === (101)) || (_8 === (69)) || (_8 === (102)) || (_8 === (70)) || (_8 === (103)) || (_8 === (71))) { */ case 2: + p.fmt.fmt_c128(v, verb); + $s = 5; continue; + /* } else if (_8 === (118)) { */ case 3: + p.fmt.fmt_c128(v, 103); + $s = 5; continue; + /* } else { */ case 4: + $r = p.badVerb(verb); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 5: + case 1: + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.fmtComplex128 }; } $f.$ptr = $ptr; $f._8 = _8; $f.p = p; $f.v = v; $f.verb = verb; $f.$s = $s; $f.$r = $r; return $f; + }; + pp.prototype.fmtComplex128 = function(v, verb) { return this.$val.fmtComplex128(v, verb); }; + pp.ptr.prototype.fmtString = function(v, verb) { + var $ptr, _9, p, v, verb, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _9 = $f._9; p = $f.p; v = $f.v; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + p = this; + _9 = verb; + /* */ if (_9 === (118)) { $s = 2; continue; } + /* */ if (_9 === (115)) { $s = 3; continue; } + /* */ if (_9 === (120)) { $s = 4; continue; } + /* */ if (_9 === (88)) { $s = 5; continue; } + /* */ if (_9 === (113)) { $s = 6; continue; } + /* */ $s = 7; continue; + /* if (_9 === (118)) { */ case 2: + if (p.fmt.fmtFlags.sharpV) { + p.fmt.fmt_q(v); + } else { + p.fmt.fmt_s(v); + } + $s = 8; continue; + /* } else if (_9 === (115)) { */ case 3: + p.fmt.fmt_s(v); + $s = 8; continue; + /* } else if (_9 === (120)) { */ case 4: + p.fmt.fmt_sx(v, "0123456789abcdef"); + $s = 8; continue; + /* } else if (_9 === (88)) { */ case 5: + p.fmt.fmt_sx(v, "0123456789ABCDEF"); + $s = 8; continue; + /* } else if (_9 === (113)) { */ case 6: + p.fmt.fmt_q(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; case -1: } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.fmtString }; } $f.$ptr = $ptr; $f._9 = _9; $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, typ, depth) { + var $ptr, _10, _i, _r$2, _r$3, _r$4, _r$5, _r$6, _ref, c, depth, i, p, typ, v, verb, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _10 = $f._10; _i = $f._i; _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; c = $f.c; depth = $f.depth; i = $f.i; p = $f.p; typ = $f.typ; v = $f.v; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + p = this; + /* */ if ((verb === 118) || (verb === 100)) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if ((verb === 118) || (verb === 100)) { */ case 1: + /* */ if (p.fmt.fmtFlags.sharpV) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (p.fmt.fmtFlags.sharpV) { */ case 3: + /* */ if (v === sliceType.nil) { $s = 6; continue; } + /* */ $s = 7; continue; + /* if (v === sliceType.nil) { */ case 6: + /* */ if ($interfaceIsEqual(typ, $ifaceNil)) { $s = 8; continue; } + /* */ $s = 9; continue; + /* if ($interfaceIsEqual(typ, $ifaceNil)) { */ case 8: + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("[]byte(nil)"); + $s = 10; continue; + /* } else { */ case 9: + _r$2 = typ.String(); /* */ $s = 11; case 11: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _r$3 = (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 = 12; case 12: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _r$3; + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).Write(nilParenBytes); + /* } */ case 10: + return; + /* } */ case 7: + /* */ if ($interfaceIsEqual(typ, $ifaceNil)) { $s = 13; continue; } + /* */ $s = 14; continue; + /* if ($interfaceIsEqual(typ, $ifaceNil)) { */ case 13: + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).Write(bytesBytes); + $s = 15; continue; + /* } else { */ case 14: + _r$4 = typ.String(); /* */ $s = 16; case 16: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + _r$5 = (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(_r$4); /* */ $s = 17; case 17: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + _r$5; + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(123); + /* } */ case 15: + $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))).WriteByte(91); + /* } */ case 5: + _ref = v; + _i = 0; + /* while (true) { */ case 18: + /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 19; continue; } + i = _i; + c = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _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))).Write(commaSpaceBytes); + } 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$6 = p.printArg(new $Uint8(c), 118, depth + 1 >> 0); /* */ $s = 20; case 20: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + _r$6; + _i++; + /* } */ $s = 18; continue; case 19: + 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); + } + return; + /* } */ case 2: + _10 = verb; + /* */ if (_10 === (115)) { $s = 22; continue; } + /* */ if (_10 === (120)) { $s = 23; continue; } + /* */ if (_10 === (88)) { $s = 24; continue; } + /* */ if (_10 === (113)) { $s = 25; continue; } + /* */ $s = 26; continue; + /* if (_10 === (115)) { */ case 22: + p.fmt.fmt_s($bytesToString(v)); + $s = 27; continue; + /* } else if (_10 === (120)) { */ case 23: + p.fmt.fmt_bx(v, "0123456789abcdef"); + $s = 27; continue; + /* } else if (_10 === (88)) { */ case 24: + p.fmt.fmt_bx(v, "0123456789ABCDEF"); + $s = 27; continue; + /* } else if (_10 === (113)) { */ case 25: + p.fmt.fmt_q($bytesToString(v)); + $s = 27; continue; + /* } else { */ case 26: + $r = p.badVerb(verb); /* */ $s = 28; case 28: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 27: + case 21: + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.fmtBytes }; } $f.$ptr = $ptr; $f._10 = _10; $f._i = _i; $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.c = c; $f.depth = depth; $f.i = i; $f.p = p; $f.typ = typ; $f.v = v; $f.verb = verb; $f.$s = $s; $f.$r = $r; return $f; + }; + pp.prototype.fmtBytes = function(v, verb, typ, depth) { return this.$val.fmtBytes(v, verb, typ, depth); }; + pp.ptr.prototype.fmtPointer = function(value, verb) { + var $ptr, _11, _12, _r$2, _r$3, p, u, use0x64, value, verb, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _11 = $f._11; _12 = $f._12; _r$2 = $f._r$2; _r$3 = $f._r$3; p = $f.p; u = $f.u; use0x64 = $f.use0x64; value = $f.value; verb = $f.verb; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + value = value; + p = this; + use0x64 = true; + _11 = verb; + /* */ if ((_11 === (112)) || (_11 === (118))) { $s = 2; continue; } + /* */ if ((_11 === (98)) || (_11 === (100)) || (_11 === (111)) || (_11 === (120)) || (_11 === (88))) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if ((_11 === (112)) || (_11 === (118))) { */ case 2: + $s = 5; continue; + /* } else if ((_11 === (98)) || (_11 === (100)) || (_11 === (111)) || (_11 === (120)) || (_11 === (88))) { */ case 3: + use0x64 = false; + $s = 5; continue; + /* } else { */ case 4: + $r = p.badVerb(verb); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + return; + /* } */ case 5: + case 1: + u = 0; + _12 = value.Kind(); + /* */ if ((_12 === (18)) || (_12 === (19)) || (_12 === (21)) || (_12 === (22)) || (_12 === (23)) || (_12 === (26))) { $s = 8; continue; } + /* */ $s = 9; continue; + /* if ((_12 === (18)) || (_12 === (19)) || (_12 === (21)) || (_12 === (22)) || (_12 === (23)) || (_12 === (26))) { */ case 8: + u = value.Pointer(); + $s = 10; continue; + /* } else { */ case 9: + $r = p.badVerb(verb); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + return; + /* } */ case 10: + case 7: + /* */ if (p.fmt.fmtFlags.sharpV) { $s = 12; continue; } + /* */ if ((verb === 118) && (u === 0)) { $s = 13; continue; } + /* */ $s = 14; continue; + /* if (p.fmt.fmtFlags.sharpV) { */ case 12: + p.add(40); + _r$2 = value.Type().String(); /* */ $s = 16; case 16: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _r$3 = (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 = 17; case 17: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _r$3; + p.add(41); + p.add(40); + if (u === 0) { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).Write(nilBytes); + } else { + p.fmt0x64(new $Uint64(0, u.constructor === Number ? u : 1), true); + } + p.add(41); + $s = 15; continue; + /* } else if ((verb === 118) && (u === 0)) { */ case 13: + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).Write(nilAngleBytes); + $s = 15; continue; + /* } else { */ case 14: + /* */ if (use0x64) { $s = 18; continue; } + /* */ $s = 19; continue; + /* if (use0x64) { */ case 18: + p.fmt0x64(new $Uint64(0, u.constructor === Number ? u : 1), !p.fmt.fmtFlags.sharp); + $s = 20; continue; + /* } else { */ case 19: + $r = p.fmtUint64(new $Uint64(0, u.constructor === Number ? u : 1), verb); /* */ $s = 21; case 21: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 20: + /* } */ case 15: + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.fmtPointer }; } $f.$ptr = $ptr; $f._11 = _11; $f._12 = _12; $f._r$2 = _r$2; $f._r$3 = _r$3; $f.p = p; $f.u = u; $f.use0x64 = use0x64; $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) { + var $ptr, _r$2, _r$3, arg, err, p, v, verb, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; arg = $f.arg; err = $f.err; 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$2 = reflect.ValueOf(arg); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + v = _r$2; + if ((v.Kind() === 22) && v.IsNil()) { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).Write(nilAngleBytes); + return; + } + if (p.panicking) { + $panic(err); + } + p.fmt.clearflags(); + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).Write(percentBangBytes); + p.add(verb); + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).Write(panicBytes); + p.panicking = true; + _r$3 = p.printArg(err, 118, 0); /* */ $s = 4; case 4: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _r$3; + 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); + /* } */ case 2: + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.catchPanic }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $f.arg = arg; $f.err = err; $f.p = p; $f.v = v; $f.verb = verb; $f.$s = $s; $f.$r = $r; return $f; + }; + pp.prototype.catchPanic = function(arg, verb) { return this.$val.catchPanic(arg, verb); }; + pp.ptr.prototype.clearSpecialFlags = function() { + var $ptr, p, plusV, sharpV; + plusV = false; + sharpV = false; + p = this; + plusV = p.fmt.fmtFlags.plusV; + if (plusV) { + p.fmt.fmtFlags.plus = true; + p.fmt.fmtFlags.plusV = false; + } + sharpV = p.fmt.fmtFlags.sharpV; + if (sharpV) { + p.fmt.fmtFlags.sharp = true; + p.fmt.fmtFlags.sharpV = false; + } + return [plusV, sharpV]; + }; + pp.prototype.clearSpecialFlags = function() { return this.$val.clearSpecialFlags(); }; + pp.ptr.prototype.restoreSpecialFlags = function(plusV, sharpV) { + var $ptr, p, plusV, sharpV; + p = this; + if (plusV) { + p.fmt.fmtFlags.plus = false; + p.fmt.fmtFlags.plusV = true; + } + if (sharpV) { + p.fmt.fmtFlags.sharp = false; + p.fmt.fmtFlags.sharpV = true; + } + }; + pp.prototype.restoreSpecialFlags = function(plusV, sharpV) { return this.$val.restoreSpecialFlags(plusV, sharpV); }; + pp.ptr.prototype.handleMethods = function(verb, depth) { + var $ptr, _13, _r$2, _r$3, _r$4, _r$5, _r$6, _ref, _tuple, _tuple$1, _tuple$2, depth, 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; $ptr = $f.$ptr; _13 = $f._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; _ref = $f._ref; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _tuple$2 = $f._tuple$2; depth = $f.depth; 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) { + 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; + _tuple$1 = p.clearSpecialFlags(); + $deferred.push([$methodVal(p, "restoreSpecialFlags"), [_tuple$1[0], _tuple$1[1]]]); + $deferred.push([$methodVal(p, "catchPanic"), [p.arg, verb]]); + $r = formatter.Format(p, verb); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + return handled; + /* } */ case 2: + /* */ if (p.fmt.fmtFlags.sharpV) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (p.fmt.fmtFlags.sharpV) { */ case 4: + _tuple$2 = $assertType(p.arg, GoStringer, true); + stringer = _tuple$2[0]; + ok$1 = _tuple$2[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]]); + _r$2 = stringer.GoString(); /* */ $s = 9; case 9: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + $r = p.fmt.fmt_s(_r$2); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + return handled; + /* } */ case 8: + $s = 6; continue; + /* } else { */ case 5: + _13 = verb; + /* */ if ((_13 === (118)) || (_13 === (115)) || (_13 === (120)) || (_13 === (88)) || (_13 === (113))) { $s = 12; continue; } + /* */ $s = 13; continue; + /* if ((_13 === (118)) || (_13 === (115)) || (_13 === (120)) || (_13 === (88)) || (_13 === (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]]); + _r$3 = v.Error(); /* */ $s = 17; case 17: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _r$4 = p.printArg(new $String(_r$3), verb, depth); /* */ $s = 18; case 18: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + _r$4; + return handled; + /* } else if ($assertType(_ref, Stringer, true)[1]) { */ case 15: + v$1 = _ref; + handled = true; + $deferred.push([$methodVal(p, "catchPanic"), [p.arg, verb]]); + _r$5 = v$1.String(); /* */ $s = 19; case 19: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + _r$6 = p.printArg(new $String(_r$5), verb, depth); /* */ $s = 20; case 20: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + _r$6; + return handled; + /* } */ case 16: + /* } */ case 13: + case 11: + /* } */ case 6: + handled = false; + 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.$ptr = $ptr; $f._13 = _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._ref = _ref; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._tuple$2 = _tuple$2; $f.depth = depth; $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, depth) { return this.$val.handleMethods(verb, depth); }; + pp.ptr.prototype.printArg = function(arg, verb, depth) { + var $ptr, _14, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _ref, arg, depth, 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, handled, p, verb, wasString, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _14 = $f._14; _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; arg = $f.arg; depth = $f.depth; 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; handled = $f.handled; p = $f.p; verb = $f.verb; wasString = $f.wasString; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + wasString = false; + 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: + /* */ if ((verb === 84) || (verb === 118)) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if ((verb === 84) || (verb === 118)) { */ case 3: + p.fmt.pad(nilAngleBytes); + $s = 5; continue; + /* } else { */ case 4: + $r = p.badVerb(verb); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 5: + wasString = false; + return wasString; + /* } */ case 2: + _14 = verb; + /* */ if (_14 === (84)) { $s = 8; continue; } + /* */ if (_14 === (112)) { $s = 9; continue; } + /* */ $s = 10; continue; + /* if (_14 === (84)) { */ case 8: + _r$2 = reflect.TypeOf(arg).String(); /* */ $s = 11; case 11: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _r$3 = p.printArg(new $String(_r$2), 115, 0); /* */ $s = 12; case 12: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _r$3; + wasString = false; + return wasString; + /* } else if (_14 === (112)) { */ case 9: + _r$4 = reflect.ValueOf(arg); /* */ $s = 13; case 13: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + $r = p.fmtPointer(_r$4, verb); /* */ $s = 14; case 14: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + wasString = false; + return wasString; + /* } */ case 10: + case 7: + _ref = arg; + /* */ if ($assertType(_ref, $Bool, true)[1]) { $s = 15; continue; } + /* */ if ($assertType(_ref, $Float32, true)[1]) { $s = 16; continue; } + /* */ if ($assertType(_ref, $Float64, true)[1]) { $s = 17; continue; } + /* */ if ($assertType(_ref, $Complex64, true)[1]) { $s = 18; continue; } + /* */ if ($assertType(_ref, $Complex128, true)[1]) { $s = 19; continue; } + /* */ if ($assertType(_ref, $Int, true)[1]) { $s = 20; continue; } + /* */ if ($assertType(_ref, $Int8, true)[1]) { $s = 21; continue; } + /* */ if ($assertType(_ref, $Int16, true)[1]) { $s = 22; continue; } + /* */ if ($assertType(_ref, $Int32, true)[1]) { $s = 23; continue; } + /* */ if ($assertType(_ref, $Int64, true)[1]) { $s = 24; continue; } + /* */ if ($assertType(_ref, $Uint, true)[1]) { $s = 25; continue; } + /* */ if ($assertType(_ref, $Uint8, true)[1]) { $s = 26; continue; } + /* */ if ($assertType(_ref, $Uint16, true)[1]) { $s = 27; continue; } + /* */ if ($assertType(_ref, $Uint32, true)[1]) { $s = 28; continue; } + /* */ if ($assertType(_ref, $Uint64, true)[1]) { $s = 29; continue; } + /* */ if ($assertType(_ref, $Uintptr, true)[1]) { $s = 30; continue; } + /* */ if ($assertType(_ref, $String, true)[1]) { $s = 31; continue; } + /* */ if ($assertType(_ref, sliceType, true)[1]) { $s = 32; continue; } + /* */ if ($assertType(_ref, reflect.Value, true)[1]) { $s = 33; continue; } + /* */ $s = 34; continue; + /* if ($assertType(_ref, $Bool, true)[1]) { */ case 15: + f = _ref.$val; + $r = p.fmtBool(f, verb); /* */ $s = 36; case 36: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 35; continue; + /* } else if ($assertType(_ref, $Float32, true)[1]) { */ case 16: + f$1 = _ref.$val; + $r = p.fmtFloat32(f$1, verb); /* */ $s = 37; case 37: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 35; continue; + /* } else if ($assertType(_ref, $Float64, true)[1]) { */ case 17: + f$2 = _ref.$val; + $r = p.fmtFloat64(f$2, verb); /* */ $s = 38; case 38: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 35; continue; + /* } else if ($assertType(_ref, $Complex64, true)[1]) { */ case 18: + f$3 = _ref.$val; + $r = p.fmtComplex64(f$3, verb); /* */ $s = 39; case 39: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 35; continue; + /* } else if ($assertType(_ref, $Complex128, true)[1]) { */ case 19: + f$4 = _ref.$val; + $r = p.fmtComplex128(f$4, verb); /* */ $s = 40; case 40: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 35; continue; + /* } else if ($assertType(_ref, $Int, true)[1]) { */ case 20: + f$5 = _ref.$val; + $r = p.fmtInt64(new $Int64(0, f$5), verb); /* */ $s = 41; case 41: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 35; continue; + /* } else if ($assertType(_ref, $Int8, true)[1]) { */ case 21: + f$6 = _ref.$val; + $r = p.fmtInt64(new $Int64(0, f$6), verb); /* */ $s = 42; case 42: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 35; continue; + /* } else if ($assertType(_ref, $Int16, true)[1]) { */ case 22: + f$7 = _ref.$val; + $r = p.fmtInt64(new $Int64(0, f$7), verb); /* */ $s = 43; case 43: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 35; continue; + /* } else if ($assertType(_ref, $Int32, true)[1]) { */ case 23: + f$8 = _ref.$val; + $r = p.fmtInt64(new $Int64(0, f$8), verb); /* */ $s = 44; case 44: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 35; continue; + /* } else if ($assertType(_ref, $Int64, true)[1]) { */ case 24: + f$9 = _ref.$val; + $r = p.fmtInt64(f$9, verb); /* */ $s = 45; case 45: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 35; continue; + /* } else if ($assertType(_ref, $Uint, true)[1]) { */ case 25: + f$10 = _ref.$val; + $r = p.fmtUint64(new $Uint64(0, f$10), verb); /* */ $s = 46; case 46: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 35; continue; + /* } else if ($assertType(_ref, $Uint8, true)[1]) { */ case 26: + f$11 = _ref.$val; + $r = p.fmtUint64(new $Uint64(0, f$11), verb); /* */ $s = 47; case 47: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 35; continue; + /* } else if ($assertType(_ref, $Uint16, true)[1]) { */ case 27: + f$12 = _ref.$val; + $r = p.fmtUint64(new $Uint64(0, f$12), verb); /* */ $s = 48; case 48: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 35; continue; + /* } else if ($assertType(_ref, $Uint32, true)[1]) { */ case 28: + f$13 = _ref.$val; + $r = p.fmtUint64(new $Uint64(0, f$13), verb); /* */ $s = 49; case 49: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 35; continue; + /* } else if ($assertType(_ref, $Uint64, true)[1]) { */ case 29: + f$14 = _ref.$val; + $r = p.fmtUint64(f$14, verb); /* */ $s = 50; case 50: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 35; continue; + /* } else if ($assertType(_ref, $Uintptr, true)[1]) { */ case 30: + f$15 = _ref.$val; + $r = p.fmtUint64(new $Uint64(0, f$15.constructor === Number ? f$15 : 1), verb); /* */ $s = 51; case 51: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 35; continue; + /* } else if ($assertType(_ref, $String, true)[1]) { */ case 31: + f$16 = _ref.$val; + $r = p.fmtString(f$16, verb); /* */ $s = 52; case 52: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + wasString = (verb === 115) || (verb === 118); + $s = 35; continue; + /* } else if ($assertType(_ref, sliceType, true)[1]) { */ case 32: + f$17 = _ref.$val; + $r = p.fmtBytes(f$17, verb, $ifaceNil, depth); /* */ $s = 53; case 53: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + wasString = verb === 115; + $s = 35; continue; + /* } else if ($assertType(_ref, reflect.Value, true)[1]) { */ case 33: + f$18 = _ref.$val; + _r$5 = p.printReflectValue(f$18, verb, depth); /* */ $s = 54; case 54: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + wasString = _r$5; + /* */ $s = 55; case 55: + return wasString; + /* } else { */ case 34: + f$19 = _ref; + _r$6 = p.handleMethods(verb, depth); /* */ $s = 56; case 56: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + handled = _r$6; + if (handled) { + wasString = false; + return wasString; + } + _r$7 = reflect.ValueOf(arg); /* */ $s = 57; case 57: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } + _r$8 = p.printReflectValue(_r$7, verb, depth); /* */ $s = 58; case 58: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; } + wasString = _r$8; + /* */ $s = 59; case 59: + return wasString; + /* } */ case 35: + p.arg = $ifaceNil; + return wasString; + /* */ } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.printArg }; } $f.$ptr = $ptr; $f._14 = _14; $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.arg = arg; $f.depth = depth; $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.handled = handled; $f.p = p; $f.verb = verb; $f.wasString = wasString; $f.$s = $s; $f.$r = $r; return $f; + }; + pp.prototype.printArg = function(arg, verb, depth) { return this.$val.printArg(arg, verb, depth); }; + pp.ptr.prototype.printValue = function(value, verb, depth) { + var $ptr, _15, _r$2, _r$3, _r$4, _r$5, _r$6, depth, handled, p, value, verb, wasString, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _15 = $f._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; depth = $f.depth; handled = $f.handled; p = $f.p; value = $f.value; verb = $f.verb; wasString = $f.wasString; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + wasString = false; + value = value; + p = this; + /* */ if (!value.IsValid()) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (!value.IsValid()) { */ case 1: + /* */ if ((verb === 84) || (verb === 118)) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if ((verb === 84) || (verb === 118)) { */ case 3: + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).Write(nilAngleBytes); + $s = 5; continue; + /* } else { */ case 4: + $r = p.badVerb(verb); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 5: + wasString = false; + return wasString; + /* } */ case 2: + _15 = verb; + /* */ if (_15 === (84)) { $s = 8; continue; } + /* */ if (_15 === (112)) { $s = 9; continue; } + /* */ $s = 10; continue; + /* if (_15 === (84)) { */ case 8: + _r$2 = value.Type().String(); /* */ $s = 11; case 11: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _r$3 = p.printArg(new $String(_r$2), 115, 0); /* */ $s = 12; case 12: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _r$3; + wasString = false; + return wasString; + /* } else if (_15 === (112)) { */ case 9: + $r = p.fmtPointer(value, verb); /* */ $s = 13; case 13: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + wasString = false; + return wasString; + /* } */ case 10: + case 7: + p.arg = $ifaceNil; + /* */ if (value.CanInterface()) { $s = 14; continue; } + /* */ $s = 15; continue; + /* if (value.CanInterface()) { */ case 14: + _r$4 = value.Interface(); /* */ $s = 16; case 16: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + p.arg = _r$4; + /* } */ case 15: + _r$5 = p.handleMethods(verb, depth); /* */ $s = 17; case 17: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + handled = _r$5; + if (handled) { + wasString = false; + return wasString; + } + _r$6 = p.printReflectValue(value, verb, depth); /* */ $s = 18; case 18: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + wasString = _r$6; + /* */ $s = 19; case 19: + return wasString; + /* */ } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.printValue }; } $f.$ptr = $ptr; $f._15 = _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.depth = depth; $f.handled = handled; $f.p = p; $f.value = value; $f.verb = verb; $f.wasString = wasString; $f.$s = $s; $f.$r = $r; return $f; + }; + pp.prototype.printValue = function(value, verb, depth) { return this.$val.printValue(value, verb, depth); }; + pp.ptr.prototype.printReflectValue = function(value, verb, depth) { + var $ptr, _16, _17, _i, _i$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$22, _r$23, _r$24, _r$25, _r$26, _r$27, _r$28, _r$29, _r$3, _r$30, _r$31, _r$32, _r$33, _r$34, _r$35, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _ref, _ref$1, _v, a, bytes, depth, f, f$1, i, i$1, i$2, i$3, key, keys, oldValue, p, t, typ, v, v$1, value, value$1, verb, wasString, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _16 = $f._16; _17 = $f._17; _i = $f._i; _i$1 = $f._i$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$22 = $f._r$22; _r$23 = $f._r$23; _r$24 = $f._r$24; _r$25 = $f._r$25; _r$26 = $f._r$26; _r$27 = $f._r$27; _r$28 = $f._r$28; _r$29 = $f._r$29; _r$3 = $f._r$3; _r$30 = $f._r$30; _r$31 = $f._r$31; _r$32 = $f._r$32; _r$33 = $f._r$33; _r$34 = $f._r$34; _r$35 = $f._r$35; _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; _v = $f._v; a = $f.a; bytes = $f.bytes; depth = $f.depth; f = $f.f; f$1 = $f.f$1; i = $f.i; i$1 = $f.i$1; i$2 = $f.i$2; i$3 = $f.i$3; key = $f.key; keys = $f.keys; oldValue = $f.oldValue; p = $f.p; t = $f.t; typ = $f.typ; v = $f.v; v$1 = $f.v$1; value = $f.value; value$1 = $f.value$1; verb = $f.verb; wasString = $f.wasString; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + wasString = false; + value = value; + p = this; + oldValue = p.value; + p.value = value; + f = value; + _16 = f.Kind(); + /* */ if (_16 === (0)) { $s = 2; continue; } + /* */ if (_16 === (1)) { $s = 3; continue; } + /* */ if ((_16 === (2)) || (_16 === (3)) || (_16 === (4)) || (_16 === (5)) || (_16 === (6))) { $s = 4; continue; } + /* */ if ((_16 === (7)) || (_16 === (8)) || (_16 === (9)) || (_16 === (10)) || (_16 === (11)) || (_16 === (12))) { $s = 5; continue; } + /* */ if ((_16 === (13)) || (_16 === (14))) { $s = 6; continue; } + /* */ if ((_16 === (15)) || (_16 === (16))) { $s = 7; continue; } + /* */ if (_16 === (24)) { $s = 8; continue; } + /* */ if (_16 === (21)) { $s = 9; continue; } + /* */ if (_16 === (25)) { $s = 10; continue; } + /* */ if (_16 === (20)) { $s = 11; continue; } + /* */ if ((_16 === (17)) || (_16 === (23))) { $s = 12; continue; } + /* */ if (_16 === (22)) { $s = 13; continue; } + /* */ if ((_16 === (18)) || (_16 === (19)) || (_16 === (26))) { $s = 14; continue; } + /* */ $s = 15; continue; + /* if (_16 === (0)) { */ case 2: + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(""); + $s = 16; continue; + /* } else if (_16 === (1)) { */ case 3: + $r = p.fmtBool(f.Bool(), verb); /* */ $s = 17; case 17: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 16; continue; + /* } else if ((_16 === (2)) || (_16 === (3)) || (_16 === (4)) || (_16 === (5)) || (_16 === (6))) { */ case 4: + $r = p.fmtInt64(f.Int(), verb); /* */ $s = 18; case 18: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 16; continue; + /* } else if ((_16 === (7)) || (_16 === (8)) || (_16 === (9)) || (_16 === (10)) || (_16 === (11)) || (_16 === (12))) { */ case 5: + $r = p.fmtUint64(f.Uint(), verb); /* */ $s = 19; case 19: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 16; continue; + /* } else if ((_16 === (13)) || (_16 === (14))) { */ case 6: + _r$2 = f.Type().Size(); /* */ $s = 23; case 23: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + /* */ if (_r$2 === 4) { $s = 20; continue; } + /* */ $s = 21; continue; + /* if (_r$2 === 4) { */ case 20: + $r = p.fmtFloat32($fround(f.Float()), verb); /* */ $s = 24; case 24: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 22; continue; + /* } else { */ case 21: + $r = p.fmtFloat64(f.Float(), verb); /* */ $s = 25; case 25: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 22: + $s = 16; continue; + /* } else if ((_16 === (15)) || (_16 === (16))) { */ case 7: + _r$3 = f.Type().Size(); /* */ $s = 29; case 29: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + /* */ if (_r$3 === 8) { $s = 26; continue; } + /* */ $s = 27; continue; + /* if (_r$3 === 8) { */ case 26: + $r = p.fmtComplex64((x = f.Complex(), new $Complex64(x.$real, x.$imag)), verb); /* */ $s = 30; case 30: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 28; continue; + /* } else { */ case 27: + $r = p.fmtComplex128(f.Complex(), verb); /* */ $s = 31; case 31: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 28: + $s = 16; continue; + /* } else if (_16 === (24)) { */ case 8: + _r$4 = f.String(); /* */ $s = 32; case 32: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + $r = p.fmtString(_r$4, verb); /* */ $s = 33; case 33: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 16; continue; + /* } else if (_16 === (21)) { */ case 9: + /* */ if (p.fmt.fmtFlags.sharpV) { $s = 34; continue; } + /* */ $s = 35; continue; + /* if (p.fmt.fmtFlags.sharpV) { */ case 34: + _r$5 = f.Type().String(); /* */ $s = 37; case 37: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + _r$6 = (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 = 38; case 38: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + _r$6; + if (f.IsNil()) { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("(nil)"); + /* break; */ $s = 1; continue; + } + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(123); + $s = 36; continue; + /* } else { */ case 35: + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).Write(mapBytes); + /* } */ case 36: + _r$7 = f.MapKeys(); /* */ $s = 39; case 39: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } + keys = _r$7; + _ref = keys; + _i = 0; + /* while (true) { */ case 40: + /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 41; continue; } + i = _i; + key = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _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))).Write(commaSpaceBytes); + } 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$8 = p.printValue(key, verb, depth + 1 >> 0); /* */ $s = 42; case 42: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; } + _r$8; + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(58); + _r$9 = f.MapIndex(key); /* */ $s = 43; case 43: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; } + _r$10 = p.printValue(_r$9, verb, depth + 1 >> 0); /* */ $s = 44; case 44: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; } + _r$10; + _i++; + /* } */ $s = 40; continue; case 41: + 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 = 16; continue; + /* } else if (_16 === (25)) { */ case 10: + /* */ if (p.fmt.fmtFlags.sharpV) { $s = 45; continue; } + /* */ $s = 46; continue; + /* if (p.fmt.fmtFlags.sharpV) { */ case 45: + _r$11 = value.Type().String(); /* */ $s = 47; case 47: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; } + _r$12 = (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(_r$11); /* */ $s = 48; case 48: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; } + _r$12; + /* } */ case 46: + p.add(123); + v = f; + t = v.Type(); + i$1 = 0; + /* while (true) { */ case 49: + /* if (!(i$1 < v.NumField())) { break; } */ if(!(i$1 < v.NumField())) { $s = 50; 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))).Write(commaSpaceBytes); + } 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 = 51; continue; } + /* */ $s = 52; continue; + /* if (p.fmt.fmtFlags.plusV || p.fmt.fmtFlags.sharpV) { */ case 51: + _r$13 = t.Field(i$1); /* */ $s = 53; case 53: if($c) { $c = false; _r$13 = _r$13.$blk(); } if (_r$13 && _r$13.$blk !== undefined) { break s; } + f$1 = $clone(_r$13, reflect.StructField); + if (!(f$1.Name === "")) { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(f$1.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 52: + _r$14 = getField(v, i$1); /* */ $s = 54; case 54: if($c) { $c = false; _r$14 = _r$14.$blk(); } if (_r$14 && _r$14.$blk !== undefined) { break s; } + _r$15 = p.printValue(_r$14, verb, depth + 1 >> 0); /* */ $s = 55; case 55: if($c) { $c = false; _r$15 = _r$15.$blk(); } if (_r$15 && _r$15.$blk !== undefined) { break s; } + _r$15; + i$1 = i$1 + (1) >> 0; + /* } */ $s = 49; continue; case 50: + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(125); + $s = 16; continue; + /* } else if (_16 === (20)) { */ case 11: + _r$16 = f.Elem(); /* */ $s = 56; case 56: if($c) { $c = false; _r$16 = _r$16.$blk(); } if (_r$16 && _r$16.$blk !== undefined) { break s; } + value$1 = _r$16; + /* */ if (!value$1.IsValid()) { $s = 57; continue; } + /* */ $s = 58; continue; + /* if (!value$1.IsValid()) { */ case 57: + /* */ if (p.fmt.fmtFlags.sharpV) { $s = 60; continue; } + /* */ $s = 61; continue; + /* if (p.fmt.fmtFlags.sharpV) { */ case 60: + _r$17 = f.Type().String(); /* */ $s = 63; case 63: if($c) { $c = false; _r$17 = _r$17.$blk(); } if (_r$17 && _r$17.$blk !== undefined) { break s; } + _r$18 = (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(_r$17); /* */ $s = 64; case 64: if($c) { $c = false; _r$18 = _r$18.$blk(); } if (_r$18 && _r$18.$blk !== undefined) { break s; } + _r$18; + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).Write(nilParenBytes); + $s = 62; continue; + /* } else { */ case 61: + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).Write(nilAngleBytes); + /* } */ case 62: + $s = 59; continue; + /* } else { */ case 58: + _r$19 = p.printValue(value$1, verb, depth + 1 >> 0); /* */ $s = 65; case 65: if($c) { $c = false; _r$19 = _r$19.$blk(); } if (_r$19 && _r$19.$blk !== undefined) { break s; } + wasString = _r$19; + /* } */ case 59: + $s = 16; continue; + /* } else if ((_16 === (17)) || (_16 === (23))) { */ case 12: + typ = f.Type(); + _r$20 = typ.Elem(); /* */ $s = 69; case 69: if($c) { $c = false; _r$20 = _r$20.$blk(); } if (_r$20 && _r$20.$blk !== undefined) { break s; } + _r$21 = _r$20.Kind(); /* */ $s = 70; case 70: if($c) { $c = false; _r$21 = _r$21.$blk(); } if (_r$21 && _r$21.$blk !== undefined) { break s; } + if (!(_r$21 === 8)) { _v = false; $s = 68; continue s; } + _r$22 = typ.Elem(); /* */ $s = 71; case 71: if($c) { $c = false; _r$22 = _r$22.$blk(); } if (_r$22 && _r$22.$blk !== undefined) { break s; } + _v = $interfaceIsEqual(_r$22, byteType) || (verb === 115) || (verb === 113) || (verb === 120); case 68: + /* */ if (_v) { $s = 66; continue; } + /* */ $s = 67; continue; + /* if (_v) { */ case 66: + bytes = sliceType.nil; + /* */ if (f.Kind() === 23) { $s = 72; continue; } + /* */ if (f.CanAddr()) { $s = 73; continue; } + /* */ $s = 74; continue; + /* if (f.Kind() === 23) { */ case 72: + _r$23 = f.Bytes(); /* */ $s = 76; case 76: if($c) { $c = false; _r$23 = _r$23.$blk(); } if (_r$23 && _r$23.$blk !== undefined) { break s; } + bytes = _r$23; + $s = 75; continue; + /* } else if (f.CanAddr()) { */ case 73: + _r$24 = f.Slice(0, f.Len()); /* */ $s = 77; case 77: if($c) { $c = false; _r$24 = _r$24.$blk(); } if (_r$24 && _r$24.$blk !== undefined) { break s; } + _r$25 = _r$24.Bytes(); /* */ $s = 78; case 78: if($c) { $c = false; _r$25 = _r$25.$blk(); } if (_r$25 && _r$25.$blk !== undefined) { break s; } + bytes = _r$25; + $s = 75; continue; + /* } else { */ case 74: + bytes = $makeSlice(sliceType, f.Len()); + _ref$1 = bytes; + _i$1 = 0; + /* while (true) { */ case 79: + /* if (!(_i$1 < _ref$1.$length)) { break; } */ if(!(_i$1 < _ref$1.$length)) { $s = 80; continue; } + i$2 = _i$1; + _r$26 = f.Index(i$2); /* */ $s = 81; case 81: if($c) { $c = false; _r$26 = _r$26.$blk(); } if (_r$26 && _r$26.$blk !== undefined) { break s; } + _r$27 = _r$26.Uint(); /* */ $s = 82; case 82: if($c) { $c = false; _r$27 = _r$27.$blk(); } if (_r$27 && _r$27.$blk !== undefined) { break s; } + ((i$2 < 0 || i$2 >= bytes.$length) ? $throwRuntimeError("index out of range") : bytes.$array[bytes.$offset + i$2] = (_r$27.$low << 24 >>> 24)); + _i$1++; + /* } */ $s = 79; continue; case 80: + /* } */ case 75: + $r = p.fmtBytes(bytes, verb, typ, depth); /* */ $s = 83; case 83: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + wasString = verb === 115; + /* break; */ $s = 1; continue; + /* } */ case 67: + /* */ if (p.fmt.fmtFlags.sharpV) { $s = 84; continue; } + /* */ $s = 85; continue; + /* if (p.fmt.fmtFlags.sharpV) { */ case 84: + _r$28 = value.Type().String(); /* */ $s = 87; case 87: if($c) { $c = false; _r$28 = _r$28.$blk(); } if (_r$28 && _r$28.$blk !== undefined) { break s; } + _r$29 = (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString(_r$28); /* */ $s = 88; case 88: if($c) { $c = false; _r$29 = _r$29.$blk(); } if (_r$29 && _r$29.$blk !== undefined) { break s; } + _r$29; + if ((f.Kind() === 23) && f.IsNil()) { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteString("(nil)"); + /* break; */ $s = 1; continue; + } + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(123); + $s = 86; continue; + /* } else { */ case 85: + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(91); + /* } */ case 86: + i$3 = 0; + /* while (true) { */ case 89: + /* if (!(i$3 < f.Len())) { break; } */ if(!(i$3 < f.Len())) { $s = 90; continue; } + if (i$3 > 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))).Write(commaSpaceBytes); + } 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$30 = f.Index(i$3); /* */ $s = 91; case 91: if($c) { $c = false; _r$30 = _r$30.$blk(); } if (_r$30 && _r$30.$blk !== undefined) { break s; } + _r$31 = p.printValue(_r$30, verb, depth + 1 >> 0); /* */ $s = 92; case 92: if($c) { $c = false; _r$31 = _r$31.$blk(); } if (_r$31 && _r$31.$blk !== undefined) { break s; } + _r$31; + i$3 = i$3 + (1) >> 0; + /* } */ $s = 89; continue; case 90: + 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 = 16; continue; + /* } else if (_16 === (22)) { */ case 13: + v$1 = f.Pointer(); + /* */ if (!((v$1 === 0)) && (depth === 0)) { $s = 93; continue; } + /* */ $s = 94; continue; + /* if (!((v$1 === 0)) && (depth === 0)) { */ case 93: + _r$32 = f.Elem(); /* */ $s = 96; case 96: if($c) { $c = false; _r$32 = _r$32.$blk(); } if (_r$32 && _r$32.$blk !== undefined) { break s; } + a = _r$32; + _17 = a.Kind(); + /* */ if ((_17 === (17)) || (_17 === (23))) { $s = 97; continue; } + /* */ if (_17 === (25)) { $s = 98; continue; } + /* */ if (_17 === (21)) { $s = 99; continue; } + /* */ $s = 100; continue; + /* if ((_17 === (17)) || (_17 === (23))) { */ case 97: + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(38); + _r$33 = p.printValue(a, verb, depth + 1 >> 0); /* */ $s = 101; case 101: if($c) { $c = false; _r$33 = _r$33.$blk(); } if (_r$33 && _r$33.$blk !== undefined) { break s; } + _r$33; + /* break BigSwitch; */ $s = 1; continue s; + $s = 100; continue; + /* } else if (_17 === (25)) { */ case 98: + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(38); + _r$34 = p.printValue(a, verb, depth + 1 >> 0); /* */ $s = 102; case 102: if($c) { $c = false; _r$34 = _r$34.$blk(); } if (_r$34 && _r$34.$blk !== undefined) { break s; } + _r$34; + /* break BigSwitch; */ $s = 1; continue s; + $s = 100; continue; + /* } else if (_17 === (21)) { */ case 99: + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(38); + _r$35 = p.printValue(a, verb, depth + 1 >> 0); /* */ $s = 103; case 103: if($c) { $c = false; _r$35 = _r$35.$blk(); } if (_r$35 && _r$35.$blk !== undefined) { break s; } + _r$35; + /* break BigSwitch; */ $s = 1; continue s; + /* } */ case 100: + case 95: + /* } */ case 94: + $r = p.fmtPointer(value, verb); /* */ $s = 104; case 104: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 16; continue; + /* } else if ((_16 === (18)) || (_16 === (19)) || (_16 === (26))) { */ case 14: + $r = p.fmtPointer(value, verb); /* */ $s = 105; case 105: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 16; continue; + /* } else { */ case 15: + $r = p.unknownType(f); /* */ $s = 106; case 106: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 16: + case 1: + p.value = oldValue; + wasString = wasString; + return wasString; + /* */ } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.printReflectValue }; } $f.$ptr = $ptr; $f._16 = _16; $f._17 = _17; $f._i = _i; $f._i$1 = _i$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$22 = _r$22; $f._r$23 = _r$23; $f._r$24 = _r$24; $f._r$25 = _r$25; $f._r$26 = _r$26; $f._r$27 = _r$27; $f._r$28 = _r$28; $f._r$29 = _r$29; $f._r$3 = _r$3; $f._r$30 = _r$30; $f._r$31 = _r$31; $f._r$32 = _r$32; $f._r$33 = _r$33; $f._r$34 = _r$34; $f._r$35 = _r$35; $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._v = _v; $f.a = a; $f.bytes = bytes; $f.depth = depth; $f.f = f; $f.f$1 = f$1; $f.i = i; $f.i$1 = i$1; $f.i$2 = i$2; $f.i$3 = i$3; $f.key = key; $f.keys = keys; $f.oldValue = oldValue; $f.p = p; $f.t = t; $f.typ = typ; $f.v = v; $f.v$1 = v$1; $f.value = value; $f.value$1 = value$1; $f.verb = verb; $f.wasString = wasString; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + pp.prototype.printReflectValue = function(value, verb, depth) { return this.$val.printReflectValue(value, verb, depth); }; + intFromArg = function(a, argNum) { + var $ptr, _18, _r$2, _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; $ptr = $f.$ptr; _18 = $f._18; _r$2 = $f._r$2; _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") : 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$2 = reflect.ValueOf(((argNum < 0 || argNum >= a.$length) ? $throwRuntimeError("index out of range") : a.$array[a.$offset + argNum])); /* */ $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; + _18 = v.Kind(); + if ((_18 === (2)) || (_18 === (3)) || (_18 === (4)) || (_18 === (5)) || (_18 === (6))) { + n = v.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 ((_18 === (7)) || (_18 === (8)) || (_18 === (9)) || (_18 === (10)) || (_18 === (11)) || (_18 === (12))) { + n$1 = v.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: + return [num, isInt, newArgNum]; + /* */ } return; } if ($f === undefined) { $f = { $blk: intFromArg }; } $f.$ptr = $ptr; $f._18 = _18; $f._r$2 = _r$2; $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 $ptr, _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 $ptr, _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(format.substring(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.doPrintf = function(format, a) { + var $ptr, _19, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _tuple, _tuple$1, _tuple$2, _tuple$3, _tuple$4, _tuple$5, _tuple$6, _tuple$7, a, afterIndex, arg, arg$1, argNum, c, end, format, i, lasti, p, w, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _19 = $f._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; _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; arg$1 = $f.arg$1; argNum = $f.argNum; c = $f.c; end = $f.end; format = $f.format; i = $f.i; lasti = $f.lasti; p = $f.p; w = $f.w; $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(format.substring(lasti, i)); + } + if (i >= end) { + /* break; */ $s = 2; continue; + } + i = i + (1) >> 0; + p.fmt.clearflags(); + F: + while (true) { + if (!(i < end)) { break; } + _19 = format.charCodeAt(i); + if (_19 === (35)) { + p.fmt.fmtFlags.sharp = true; + } else if (_19 === (48)) { + p.fmt.fmtFlags.zero = true; + } else if (_19 === (43)) { + p.fmt.fmtFlags.plus = true; + } else if (_19 === (45)) { + p.fmt.fmtFlags.minus = true; + } else if (_19 === (32)) { + p.fmt.fmtFlags.space = true; + } else { + break F; + } + i = i + (1) >> 0; + } + _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 = 3; continue; } + /* */ $s = 4; continue; + /* if (i < end && (format.charCodeAt(i) === 42)) { */ case 3: + i = i + (1) >> 0; + _r$2 = intFromArg(a, argNum); /* */ $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; + 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))).Write(badWidthBytes); + } + if (p.fmt.wid < 0) { + p.fmt.wid = -p.fmt.wid; + p.fmt.fmtFlags.minus = true; + } + afterIndex = false; + $s = 5; continue; + /* } else { */ case 4: + _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 5: + /* */ if ((i + 1 >> 0) < end && (format.charCodeAt(i) === 46)) { $s = 7; continue; } + /* */ $s = 8; continue; + /* if ((i + 1 >> 0) < end && (format.charCodeAt(i) === 46)) { */ case 7: + 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 = 9; continue; } + /* */ $s = 10; continue; + /* if (i < end && (format.charCodeAt(i) === 42)) { */ case 9: + i = i + (1) >> 0; + _r$3 = intFromArg(a, argNum); /* */ $s = 12; case 12: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _tuple$4 = _r$3; + 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))).Write(badPrecBytes); + } + afterIndex = false; + $s = 11; continue; + /* } else { */ case 10: + _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 11: + /* } */ case 8: + 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) { $s = 13; continue; } + /* */ $s = 14; continue; + /* if (i >= end) { */ case 13: + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).Write(noVerbBytes); + /* continue; */ $s = 1; continue; + /* } */ case 14: + _tuple$7 = utf8.DecodeRuneInString(format.substring(i)); + c = _tuple$7[0]; + w = _tuple$7[1]; + i = i + (w) >> 0; + /* */ if (c === 37) { $s = 15; continue; } + /* */ $s = 16; continue; + /* if (c === 37) { */ case 15: + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(37); + /* continue; */ $s = 1; continue; + /* } */ case 16: + /* */ if (!p.goodArgNum) { $s = 17; continue; } + /* */ if (argNum >= a.$length) { $s = 18; continue; } + /* */ $s = 19; continue; + /* if (!p.goodArgNum) { */ case 17: + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).Write(percentBangBytes); + p.add(c); + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).Write(badIndexBytes); + /* continue; */ $s = 1; continue; + $s = 19; continue; + /* } else if (argNum >= a.$length) { */ case 18: + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).Write(percentBangBytes); + p.add(c); + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).Write(missingBytes); + /* continue; */ $s = 1; continue; + /* } */ case 19: + arg = ((argNum < 0 || argNum >= a.$length) ? $throwRuntimeError("index out of range") : a.$array[a.$offset + argNum]); + argNum = argNum + (1) >> 0; + if (c === 118) { + if (p.fmt.fmtFlags.sharp) { + p.fmt.fmtFlags.sharp = false; + p.fmt.fmtFlags.sharpV = true; + } + if (p.fmt.fmtFlags.plus) { + p.fmt.fmtFlags.plus = false; + p.fmt.fmtFlags.plusV = true; + } + } + _r$4 = p.printArg(arg, c, 0); /* */ $s = 20; case 20: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + _r$4; + /* } */ $s = 1; continue; case 2: + /* */ if (!p.reordered && argNum < a.$length) { $s = 21; continue; } + /* */ $s = 22; continue; + /* if (!p.reordered && argNum < a.$length) { */ case 21: + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).Write(extraBytes); + /* while (true) { */ case 23: + /* if (!(argNum < a.$length)) { break; } */ if(!(argNum < a.$length)) { $s = 24; continue; } + arg$1 = ((argNum < 0 || argNum >= a.$length) ? $throwRuntimeError("index out of range") : a.$array[a.$offset + argNum]); + /* */ if (!($interfaceIsEqual(arg$1, $ifaceNil))) { $s = 25; continue; } + /* */ $s = 26; continue; + /* if (!($interfaceIsEqual(arg$1, $ifaceNil))) { */ case 25: + _r$5 = reflect.TypeOf(arg$1).String(); /* */ $s = 27; case 27: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + _r$6 = (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 = 28; case 28: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + _r$6; + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(61); + /* } */ case 26: + _r$7 = p.printArg(arg$1, 118, 0); /* */ $s = 29; case 29: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } + _r$7; + if ((argNum + 1 >> 0) < a.$length) { + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).Write(commaSpaceBytes); + } + argNum = argNum + (1) >> 0; + /* } */ $s = 23; continue; case 24: + (p.$ptr_buf || (p.$ptr_buf = new ptrType$1(function() { return this.$target.buf; }, function($v) { this.$target.buf = $v; }, p))).WriteByte(41); + /* } */ case 22: + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.doPrintf }; } $f.$ptr = $ptr; $f._19 = _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._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.arg$1 = arg$1; $f.argNum = argNum; $f.c = c; $f.end = end; $f.format = format; $f.i = i; $f.lasti = lasti; $f.p = p; $f.w = w; $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, addspace, addnewline) { + var $ptr, _r$2, _r$3, _v, a, addnewline, addspace, arg, argNum, isString, p, prevString, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; _v = $f._v; a = $f.a; addnewline = $f.addnewline; addspace = $f.addspace; 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; + argNum = 0; + /* while (true) { */ case 1: + /* if (!(argNum < a.$length)) { break; } */ if(!(argNum < a.$length)) { $s = 2; continue; } + p.fmt.clearflags(); + arg = ((argNum < 0 || argNum >= a.$length) ? $throwRuntimeError("index out of range") : a.$array[a.$offset + argNum]); + /* */ if (argNum > 0) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (argNum > 0) { */ case 3: + if (!(!($interfaceIsEqual(arg, $ifaceNil)))) { _v = false; $s = 5; continue s; } + _r$2 = reflect.TypeOf(arg).Kind(); /* */ $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 === 24; case 5: + isString = _v; + if (addspace || !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); + } + /* } */ case 4: + _r$3 = p.printArg(arg, 118, 0); /* */ $s = 7; case 7: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + prevString = _r$3; + argNum = argNum + (1) >> 0; + /* } */ $s = 1; continue; case 2: + if (addnewline) { + (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; case -1: } return; } if ($f === undefined) { $f = { $blk: pp.ptr.prototype.doPrint }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._v = _v; $f.a = a; $f.addnewline = addnewline; $f.addspace = addspace; $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, addspace, addnewline) { return this.$val.doPrint(a, addspace, addnewline); }; + ss.ptr.prototype.Read = function(buf) { + var $ptr, _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 $ptr, _r$2, _tuple, err, r, s, size, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _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.peekRune >= 0) { + s.count = s.count + (1) >> 0; + r = s.peekRune; + size = utf8.RuneLen(r); + s.prevRune = r; + s.peekRune = -1; + return [r, size, err]; + } + if (s.atEOF || s.ssave.nlIsEnd && (s.prevRune === 10) || s.count >= s.ssave.argLimit) { + err = io.EOF; + return [r, size, err]; + } + _r$2 = s.rr.ReadRune(); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _tuple = _r$2; + r = _tuple[0]; + size = _tuple[1]; + err = _tuple[2]; + if ($interfaceIsEqual(err, $ifaceNil)) { + s.count = s.count + (1) >> 0; + s.prevRune = r; + } else if ($interfaceIsEqual(err, io.EOF)) { + s.atEOF = true; + } + return [r, size, err]; + /* */ } return; } if ($f === undefined) { $f = { $blk: ss.ptr.prototype.ReadRune }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $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 $ptr, _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 $ptr, _r$2, _tuple, err, r, s, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _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$2 = s.ReadRune(); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _tuple = _r$2; + r = _tuple[0]; + err = _tuple[2]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + if ($interfaceIsEqual(err, io.EOF)) { + r = -1; + return r; + } + s.error(err); + } + return r; + /* */ } return; } if ($f === undefined) { $f = { $blk: ss.ptr.prototype.getRune }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $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 $ptr, _r$2, _tuple, ok, s, u, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _tuple = $f._tuple; ok = $f.ok; s = $f.s; u = $f.u; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + s = this; + _tuple = $assertType(s.rr, runeUnreader, true); + u = _tuple[0]; + ok = _tuple[1]; + /* */ if (ok) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (ok) { */ case 1: + _r$2 = u.UnreadRune(); /* */ $s = 4; case 4: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _r$2; + $s = 3; continue; + /* } else { */ case 2: + s.peekRune = s.prevRune; + /* } */ case 3: + s.prevRune = -1; + s.count = s.count - (1) >> 0; + return $ifaceNil; + /* */ } return; } if ($f === undefined) { $f = { $blk: ss.ptr.prototype.UnreadRune }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._tuple = _tuple; $f.ok = ok; $f.s = s; $f.u = u; $f.$s = $s; $f.$r = $r; return $f; + }; + ss.prototype.UnreadRune = function() { return this.$val.UnreadRune(); }; + ss.ptr.prototype.error = function(err) { + var $ptr, 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 $ptr, 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 $ptr, _r$2, err, f, s, skipSpace, tok, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; 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.nil; + err[0] = $ifaceNil; + s = this; + $deferred.push([(function(err) { return function() { + var $ptr, _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$2 = s.token(skipSpace, f); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + tok = _r$2; + 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.$ptr = $ptr; $f._r$2 = _r$2; $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 $ptr, _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") : _ref.$array[_ref.$offset + _i]), arrayType$2); + if (rx < rng[0]) { + return false; + } + if (rx <= rng[1]) { + return true; + } + _i++; + } + return false; + }; + notSpace = function(r) { + var $ptr, r; + return !isSpace(r); + }; + ss.ptr.prototype.SkipSpace = function() { + var $ptr, s, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + s = this; + $r = s.skipSpace(false); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: ss.ptr.prototype.SkipSpace }; } $f.$ptr = $ptr; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; + }; + ss.prototype.SkipSpace = function() { return this.$val.SkipSpace(); }; + ss.ptr.prototype.free = function(old) { + var $ptr, old, s; + old = $clone(old, ssave); + 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.rr = $ifaceNil; + ssFree.Put(s); + }; + ss.prototype.free = function(old) { return this.$val.free(old); }; + ss.ptr.prototype.skipSpace = function(stopAtNewline) { + var $ptr, _r$2, _r$3, _r$4, _v, r, s, stopAtNewline, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _v = $f._v; r = $f.r; s = $f.s; stopAtNewline = $f.stopAtNewline; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + s = this; + /* while (true) { */ case 1: + _r$2 = s.getRune(); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + r = _r$2; + if (r === -1) { + return; + } + if (!(r === 13)) { _v = false; $s = 6; continue s; } + _r$3 = s.peek("\n"); /* */ $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; 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 (stopAtNewline) { + /* break; */ $s = 2; continue; + } + if (s.ssave.nlIsSpace) { + /* continue; */ $s = 1; continue; + } + s.errorString("unexpected newline"); + return; + /* } */ case 9: + /* */ if (!isSpace(r)) { $s = 10; continue; } + /* */ $s = 11; continue; + /* if (!isSpace(r)) { */ case 10: + _r$4 = s.UnreadRune(); /* */ $s = 12; case 12: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + _r$4; + /* break; */ $s = 2; continue; + /* } */ case 11: + /* } */ $s = 1; continue; case 2: + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: ss.ptr.prototype.skipSpace }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._v = _v; $f.r = r; $f.s = s; $f.stopAtNewline = stopAtNewline; $f.$s = $s; $f.$r = $r; return $f; + }; + ss.prototype.skipSpace = function(stopAtNewline) { return this.$val.skipSpace(stopAtNewline); }; + ss.ptr.prototype.token = function(skipSpace, f) { + var $ptr, _r$2, _r$3, _r$4, f, r, s, skipSpace, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; 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(false); /* */ $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$2 = s.getRune(); /* */ $s = 6; case 6: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + r = _r$2; + if (r === -1) { + /* break; */ $s = 5; continue; + } + _r$3 = f(r); /* */ $s = 9; case 9: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + /* */ if (!_r$3) { $s = 7; continue; } + /* */ $s = 8; continue; + /* if (!_r$3) { */ case 7: + _r$4 = s.UnreadRune(); /* */ $s = 10; case 10: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + _r$4; + /* 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: + return (x = s.buf, $subslice(new sliceType(x.$array), x.$offset, x.$offset + x.$length)); + /* */ } return; } if ($f === undefined) { $f = { $blk: ss.ptr.prototype.token }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $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 $ptr, _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 $ptr, _r$2, _r$3, ok, r, s, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; 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$2 = s.getRune(); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + r = _r$2; + /* */ if (!((r === -1))) { $s = 2; continue; } + /* */ $s = 3; continue; + /* if (!((r === -1))) { */ case 2: + _r$3 = s.UnreadRune(); /* */ $s = 4; case 4: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _r$3; + /* } */ case 3: + return indexRune(ok, r) >= 0; + /* */ } return; } if ($f === undefined) { $f = { $blk: ss.ptr.prototype.peek }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $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: "computePadding", name: "computePadding", pkg: "fmt", typ: $funcType([$Int], [sliceType, $Int, $Int], false)}, {prop: "writePadding", name: "writePadding", pkg: "fmt", typ: $funcType([$Int, sliceType], [], false)}, {prop: "pad", name: "pad", pkg: "fmt", typ: $funcType([sliceType], [], false)}, {prop: "padString", name: "padString", pkg: "fmt", typ: $funcType([$String], [], false)}, {prop: "fmt_boolean", name: "fmt_boolean", pkg: "fmt", typ: $funcType([$Bool], [], false)}, {prop: "integer", name: "integer", pkg: "fmt", typ: $funcType([$Int64, $Uint64, $Bool, $String], [], false)}, {prop: "truncate", name: "truncate", pkg: "fmt", typ: $funcType([$String], [$String], false)}, {prop: "fmt_s", name: "fmt_s", pkg: "fmt", typ: $funcType([$String], [], false)}, {prop: "fmt_sbx", name: "fmt_sbx", pkg: "fmt", typ: $funcType([$String, sliceType, $String], [], false)}, {prop: "fmt_sx", name: "fmt_sx", pkg: "fmt", typ: $funcType([$String, $String], [], false)}, {prop: "fmt_bx", name: "fmt_bx", pkg: "fmt", typ: $funcType([sliceType, $String], [], false)}, {prop: "fmt_q", name: "fmt_q", pkg: "fmt", typ: $funcType([$String], [], false)}, {prop: "fmt_qc", name: "fmt_qc", pkg: "fmt", typ: $funcType([$Int64], [], false)}, {prop: "formatFloat", name: "formatFloat", pkg: "fmt", typ: $funcType([$Float64, $Uint8, $Int, $Int], [], false)}, {prop: "fmt_e64", name: "fmt_e64", pkg: "fmt", typ: $funcType([$Float64], [], false)}, {prop: "fmt_E64", name: "fmt_E64", pkg: "fmt", typ: $funcType([$Float64], [], false)}, {prop: "fmt_f64", name: "fmt_f64", pkg: "fmt", typ: $funcType([$Float64], [], false)}, {prop: "fmt_g64", name: "fmt_g64", pkg: "fmt", typ: $funcType([$Float64], [], false)}, {prop: "fmt_G64", name: "fmt_G64", pkg: "fmt", typ: $funcType([$Float64], [], false)}, {prop: "fmt_fb64", name: "fmt_fb64", pkg: "fmt", typ: $funcType([$Float64], [], false)}, {prop: "fmt_e32", name: "fmt_e32", pkg: "fmt", typ: $funcType([$Float32], [], false)}, {prop: "fmt_E32", name: "fmt_E32", pkg: "fmt", typ: $funcType([$Float32], [], false)}, {prop: "fmt_f32", name: "fmt_f32", pkg: "fmt", typ: $funcType([$Float32], [], false)}, {prop: "fmt_g32", name: "fmt_g32", pkg: "fmt", typ: $funcType([$Float32], [], false)}, {prop: "fmt_G32", name: "fmt_G32", pkg: "fmt", typ: $funcType([$Float32], [], false)}, {prop: "fmt_fb32", name: "fmt_fb32", pkg: "fmt", typ: $funcType([$Float32], [], false)}, {prop: "fmt_c64", name: "fmt_c64", pkg: "fmt", typ: $funcType([$Complex64, $Int32], [], false)}, {prop: "fmt_c128", name: "fmt_c128", pkg: "fmt", typ: $funcType([$Complex128, $Int32], [], false)}, {prop: "fmt_complex", name: "fmt_complex", pkg: "fmt", typ: $funcType([$Float64, $Float64, $Int, $Int32], [], false)}]; + ptrType$1.methods = [{prop: "Write", name: "Write", pkg: "", typ: $funcType([sliceType], [$Int, $error], false)}, {prop: "WriteString", name: "WriteString", pkg: "", typ: $funcType([$String], [$Int, $error], false)}, {prop: "WriteByte", name: "WriteByte", pkg: "", typ: $funcType([$Uint8], [$error], false)}, {prop: "WriteRune", name: "WriteRune", pkg: "", typ: $funcType([$Int32], [$error], 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: "add", name: "add", pkg: "fmt", typ: $funcType([$Int32], [], false)}, {prop: "Write", name: "Write", pkg: "", typ: $funcType([sliceType], [$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: "fmtC", name: "fmtC", pkg: "fmt", typ: $funcType([$Int64], [], false)}, {prop: "fmtInt64", name: "fmtInt64", pkg: "fmt", typ: $funcType([$Int64, $Int32], [], false)}, {prop: "fmt0x64", name: "fmt0x64", pkg: "fmt", typ: $funcType([$Uint64, $Bool], [], false)}, {prop: "fmtUnicode", name: "fmtUnicode", pkg: "fmt", typ: $funcType([$Int64], [], false)}, {prop: "fmtUint64", name: "fmtUint64", pkg: "fmt", typ: $funcType([$Uint64, $Int32], [], false)}, {prop: "fmtFloat32", name: "fmtFloat32", pkg: "fmt", typ: $funcType([$Float32, $Int32], [], false)}, {prop: "fmtFloat64", name: "fmtFloat64", pkg: "fmt", typ: $funcType([$Float64, $Int32], [], false)}, {prop: "fmtComplex64", name: "fmtComplex64", pkg: "fmt", typ: $funcType([$Complex64, $Int32], [], false)}, {prop: "fmtComplex128", name: "fmtComplex128", pkg: "fmt", typ: $funcType([$Complex128, $Int32], [], false)}, {prop: "fmtString", name: "fmtString", pkg: "fmt", typ: $funcType([$String, $Int32], [], false)}, {prop: "fmtBytes", name: "fmtBytes", pkg: "fmt", typ: $funcType([sliceType, $Int32, reflect.Type, $Int], [], false)}, {prop: "fmtPointer", name: "fmtPointer", pkg: "fmt", typ: $funcType([reflect.Value, $Int32], [], false)}, {prop: "catchPanic", name: "catchPanic", pkg: "fmt", typ: $funcType([$emptyInterface, $Int32], [], false)}, {prop: "clearSpecialFlags", name: "clearSpecialFlags", pkg: "fmt", typ: $funcType([], [$Bool, $Bool], false)}, {prop: "restoreSpecialFlags", name: "restoreSpecialFlags", pkg: "fmt", typ: $funcType([$Bool, $Bool], [], false)}, {prop: "handleMethods", name: "handleMethods", pkg: "fmt", typ: $funcType([$Int32, $Int], [$Bool], false)}, {prop: "printArg", name: "printArg", pkg: "fmt", typ: $funcType([$emptyInterface, $Int32, $Int], [$Bool], false)}, {prop: "printValue", name: "printValue", pkg: "fmt", typ: $funcType([reflect.Value, $Int32, $Int], [$Bool], false)}, {prop: "printReflectValue", name: "printReflectValue", pkg: "fmt", typ: $funcType([reflect.Value, $Int32, $Int], [$Bool], false)}, {prop: "argNumber", name: "argNumber", pkg: "fmt", typ: $funcType([$Int, $String, $Int, $Int], [$Int, $Int, $Bool], false)}, {prop: "doPrintf", name: "doPrintf", pkg: "fmt", typ: $funcType([$String, sliceType$1], [], false)}, {prop: "doPrint", name: "doPrint", pkg: "fmt", typ: $funcType([sliceType$1, $Bool, $Bool], [], false)}]; + ptrType$5.methods = [{prop: "Read", name: "Read", pkg: "", typ: $funcType([sliceType], [$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, $error], false)}, {prop: "SkipSpace", name: "SkipSpace", pkg: "", typ: $funcType([], [], false)}, {prop: "free", name: "free", pkg: "fmt", typ: $funcType([ssave], [], false)}, {prop: "skipSpace", name: "skipSpace", pkg: "fmt", typ: $funcType([$Bool], [], false)}, {prop: "token", name: "token", pkg: "fmt", typ: $funcType([$Bool, funcType], [sliceType], 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$1], [$Int, $error], false)}, {prop: "advance", name: "advance", pkg: "fmt", typ: $funcType([$String], [$Int], false)}, {prop: "doScanf", name: "doScanf", pkg: "fmt", typ: $funcType([$String, sliceType$1], [$Int, $error], false)}]; + fmtFlags.init([{prop: "widPresent", name: "widPresent", pkg: "fmt", typ: $Bool, tag: ""}, {prop: "precPresent", name: "precPresent", pkg: "fmt", typ: $Bool, tag: ""}, {prop: "minus", name: "minus", pkg: "fmt", typ: $Bool, tag: ""}, {prop: "plus", name: "plus", pkg: "fmt", typ: $Bool, tag: ""}, {prop: "sharp", name: "sharp", pkg: "fmt", typ: $Bool, tag: ""}, {prop: "space", name: "space", pkg: "fmt", typ: $Bool, tag: ""}, {prop: "unicode", name: "unicode", pkg: "fmt", typ: $Bool, tag: ""}, {prop: "uniQuote", name: "uniQuote", pkg: "fmt", typ: $Bool, tag: ""}, {prop: "zero", name: "zero", pkg: "fmt", typ: $Bool, tag: ""}, {prop: "plusV", name: "plusV", pkg: "fmt", typ: $Bool, tag: ""}, {prop: "sharpV", name: "sharpV", pkg: "fmt", typ: $Bool, tag: ""}]); + fmt.init([{prop: "intbuf", name: "intbuf", pkg: "fmt", typ: arrayType$1, tag: ""}, {prop: "buf", name: "buf", pkg: "fmt", typ: ptrType$1, tag: ""}, {prop: "wid", name: "wid", pkg: "fmt", typ: $Int, tag: ""}, {prop: "prec", name: "prec", pkg: "fmt", typ: $Int, tag: ""}, {prop: "fmtFlags", name: "", pkg: "fmt", typ: fmtFlags, 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], [$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([{prop: "n", name: "n", pkg: "fmt", typ: $Int, tag: ""}, {prop: "panicking", name: "panicking", pkg: "fmt", typ: $Bool, tag: ""}, {prop: "erroring", name: "erroring", pkg: "fmt", typ: $Bool, tag: ""}, {prop: "buf", name: "buf", pkg: "fmt", typ: buffer, tag: ""}, {prop: "arg", name: "arg", pkg: "fmt", typ: $emptyInterface, tag: ""}, {prop: "value", name: "value", pkg: "fmt", typ: reflect.Value, tag: ""}, {prop: "reordered", name: "reordered", pkg: "fmt", typ: $Bool, tag: ""}, {prop: "goodArgNum", name: "goodArgNum", pkg: "fmt", typ: $Bool, tag: ""}, {prop: "runeBuf", name: "runeBuf", pkg: "fmt", typ: arrayType, tag: ""}, {prop: "fmt", name: "fmt", pkg: "fmt", typ: fmt, tag: ""}]); + runeUnreader.init([{prop: "UnreadRune", name: "UnreadRune", pkg: "", typ: $funcType([], [$error], false)}]); + scanError.init([{prop: "err", name: "err", pkg: "fmt", typ: $error, tag: ""}]); + ss.init([{prop: "rr", name: "rr", pkg: "fmt", typ: io.RuneReader, tag: ""}, {prop: "buf", name: "buf", pkg: "fmt", typ: buffer, tag: ""}, {prop: "peekRune", name: "peekRune", pkg: "fmt", typ: $Int32, tag: ""}, {prop: "prevRune", name: "prevRune", pkg: "fmt", typ: $Int32, tag: ""}, {prop: "count", name: "count", pkg: "fmt", typ: $Int, tag: ""}, {prop: "atEOF", name: "atEOF", pkg: "fmt", typ: $Bool, tag: ""}, {prop: "ssave", name: "", pkg: "fmt", typ: ssave, tag: ""}]); + ssave.init([{prop: "validSave", name: "validSave", pkg: "fmt", typ: $Bool, tag: ""}, {prop: "nlIsEnd", name: "nlIsEnd", pkg: "fmt", typ: $Bool, tag: ""}, {prop: "nlIsSpace", name: "nlIsSpace", pkg: "fmt", typ: $Bool, tag: ""}, {prop: "argLimit", name: "argLimit", pkg: "fmt", typ: $Int, tag: ""}, {prop: "limit", name: "limit", pkg: "fmt", typ: $Int, tag: ""}, {prop: "maxWid", name: "maxWid", pkg: "fmt", 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 = 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 = os.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = reflect.$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 = sync.$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; } + padZeroBytes = $makeSlice(sliceType, 65); + padSpaceBytes = $makeSlice(sliceType, 65); + trueBytes = new sliceType($stringToBytes("true")); + falseBytes = new sliceType($stringToBytes("false")); + commaSpaceBytes = new sliceType($stringToBytes(", ")); + nilAngleBytes = new sliceType($stringToBytes("")); + nilParenBytes = new sliceType($stringToBytes("(nil)")); + nilBytes = new sliceType($stringToBytes("nil")); + mapBytes = new sliceType($stringToBytes("map[")); + percentBangBytes = new sliceType($stringToBytes("%!")); + missingBytes = new sliceType($stringToBytes("(MISSING)")); + badIndexBytes = new sliceType($stringToBytes("(BADINDEX)")); + panicBytes = new sliceType($stringToBytes("(PANIC=")); + extraBytes = new sliceType($stringToBytes("%!(EXTRA ")); + irparenBytes = new sliceType($stringToBytes("i)")); + bytesBytes = new sliceType($stringToBytes("[]byte{")); + badWidthBytes = new sliceType($stringToBytes("%!(BADWIDTH)")); + badPrecBytes = new sliceType($stringToBytes("%!(BADPREC)")); + noVerbBytes = new sliceType($stringToBytes("%!(NOVERB)")); + ppFree = new sync.Pool.ptr(0, 0, sliceType$1.nil, (function() { + var $ptr; + return new pp.ptr(0, false, false, buffer.nil, $ifaceNil, new reflect.Value.ptr(ptrType.nil, 0, 0), false, false, arrayType.zero(), new fmt.ptr(arrayType$1.zero(), ptrType$1.nil, 0, 0, new fmtFlags.ptr(false, false, false, false, false, false, false, false, false, false, false))); + })); + _r = reflect.TypeOf(new $Int(0)).Bits(); /* */ $s = 9; case 9: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + intBits = _r; + _r$1 = reflect.TypeOf(new $Uintptr(0)).Bits(); /* */ $s = 10; case 10: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + uintptrBits = _r$1; + byteType = reflect.TypeOf(new $Uint8(0)); + space = new sliceType$2([$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$1.nil, (function() { + var $ptr; + return new ss.ptr($ifaceNil, buffer.nil, 0, 0, 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"); + init(); + /* */ } 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, StringSlice, sliceType$2, Search, SearchStrings, insertionSort, siftDown, heapSort, medianOfThree, doPivot, quickSort, Sort; + StringSlice = $pkg.StringSlice = $newType(12, $kindSlice, "sort.StringSlice", "StringSlice", "sort", null); + sliceType$2 = $sliceType($String); + Search = function(n, f) { + var $ptr, _q, _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; $ptr = $f.$ptr; _q = $f._q; _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 + (_q = ((j - i >> 0)) / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) >> 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: + return i; + /* */ } return; } if ($f === undefined) { $f = { $blk: Search }; } $f.$ptr = $ptr; $f._q = _q; $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; + SearchStrings = function(a, x) { + var $ptr, _r, a, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _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 $ptr, i; + return ((i < 0 || i >= a[0].$length) ? $throwRuntimeError("index out of range") : 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 = 2; case 2: + return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: SearchStrings }; } $f.$ptr = $ptr; $f._r = _r; $f.a = a; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.SearchStrings = SearchStrings; + StringSlice.prototype.Search = function(x) { + var $ptr, _r, p, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _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 = SearchStrings($subslice(new sliceType$2(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 = 2; case 2: + return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: StringSlice.prototype.Search }; } $f.$ptr = $ptr; $f._r = _r; $f.p = p; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + $ptrType(StringSlice).prototype.Search = function(x) { return this.$get().Search(x); }; + insertionSort = function(data, a, b) { + var $ptr, _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; $ptr = $f.$ptr; _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; case -1: } return; } if ($f === undefined) { $f = { $blk: insertionSort }; } $f.$ptr = $ptr; $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 $ptr, _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; $ptr = $f.$ptr; _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: + 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; case -1: } return; } if ($f === undefined) { $f = { $blk: siftDown }; } $f.$ptr = $ptr; $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 $ptr, _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; $ptr = $f.$ptr; _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; case -1: } return; } if ($f === undefined) { $f = { $blk: heapSort }; } $f.$ptr = $ptr; $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 $ptr, _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; $ptr = $f.$ptr; _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; case -1: } return; } if ($f === undefined) { $f = { $blk: medianOfThree }; } $f.$ptr = $ptr; $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 = function(data, lo, hi) { + var $ptr, _q, _q$1, _q$2, _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; $ptr = $f.$ptr; _q = $f._q; _q$1 = $f._q$1; _q$2 = $f._q$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; _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 + (_q = ((hi - lo >> 0)) / 2, (_q === _q && _q !== 1/0 && _q !== -1/0) ? _q >> 0 : $throwRuntimeError("integer divide by zero")) >> 0; + /* */ if ((hi - lo >> 0) > 40) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if ((hi - lo >> 0) > 40) { */ case 1: + s = (_q$1 = ((hi - lo >> 0)) / 8, (_q$1 === _q$1 && _q$1 !== 1/0 && _q$1 !== -1/0) ? _q$1 >> 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$2 = ((hi - lo >> 0)) / 4, (_q$2 === _q$2 && _q$2 !== 1/0 && _q$2 !== -1/0) ? _q$2 >> 0 : $throwRuntimeError("integer divide by zero"))) { $s = 22; continue; } + /* */ $s = 23; continue; + /* if (!protect && (hi - c >> 0) < (_q$2 = ((hi - lo >> 0)) / 4, (_q$2 === _q$2 && _q$2 !== 1/0 && _q$2 !== -1/0) ? _q$2 >> 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; + return [midlo, midhi]; + /* */ } return; } if ($f === undefined) { $f = { $blk: doPivot }; } $f.$ptr = $ptr; $f._q = _q; $f._q$1 = _q$1; $f._q$2 = _q$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._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) { + var $ptr, _r, _r$1, _tuple, a, b, data, i, maxDepth, mhi, mlo, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; a = $f.a; b = $f.b; data = $f.data; i = $f.i; maxDepth = $f.maxDepth; 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 === 0) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (maxDepth === 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; } + return; + /* } */ case 4: + maxDepth = maxDepth - (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); /* */ $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); /* */ $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; case -1: } return; } if ($f === undefined) { $f = { $blk: quickSort }; } $f.$ptr = $ptr; $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 = maxDepth; $f.mhi = mhi; $f.mlo = mlo; $f.$s = $s; $f.$r = $r; return $f; + }; + Sort = function(data) { + var $ptr, _r, data, i, maxDepth, n, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; data = $f.data; i = $f.i; maxDepth = $f.maxDepth; 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; + maxDepth = 0; + i = n; + while (true) { + if (!(i > 0)) { break; } + maxDepth = maxDepth + (1) >> 0; + i = (i >> $min((1), 31)) >> 0; + } + maxDepth = $imul(maxDepth, (2)); + $r = quickSort(data, 0, n, maxDepth); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: Sort }; } $f.$ptr = $ptr; $f._r = _r; $f.data = data; $f.i = i; $f.maxDepth = maxDepth; $f.n = n; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.Sort = Sort; + StringSlice.prototype.Len = function() { + var $ptr, p; + p = this; + return p.$length; + }; + $ptrType(StringSlice).prototype.Len = function() { return this.$get().Len(); }; + StringSlice.prototype.Less = function(i, j) { + var $ptr, i, j, p; + p = this; + return ((i < 0 || i >= p.$length) ? $throwRuntimeError("index out of range") : p.$array[p.$offset + i]) < ((j < 0 || j >= p.$length) ? $throwRuntimeError("index out of range") : p.$array[p.$offset + j]); + }; + $ptrType(StringSlice).prototype.Less = function(i, j) { return this.$get().Less(i, j); }; + StringSlice.prototype.Swap = function(i, j) { + var $ptr, _tmp, _tmp$1, i, j, p; + p = this; + _tmp = ((j < 0 || j >= p.$length) ? $throwRuntimeError("index out of range") : p.$array[p.$offset + j]); + _tmp$1 = ((i < 0 || i >= p.$length) ? $throwRuntimeError("index out of range") : p.$array[p.$offset + i]); + ((i < 0 || i >= p.$length) ? $throwRuntimeError("index out of range") : p.$array[p.$offset + i] = _tmp); + ((j < 0 || j >= p.$length) ? $throwRuntimeError("index out of range") : p.$array[p.$offset + j] = _tmp$1); + }; + $ptrType(StringSlice).prototype.Swap = function(i, j) { return this.$get().Swap(i, j); }; + StringSlice.prototype.Sort = function() { + var $ptr, p, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; 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; case -1: } return; } if ($f === undefined) { $f = { $blk: StringSlice.prototype.Sort }; } $f.$ptr = $ptr; $f.p = p; $f.$s = $s; $f.$r = $r; return $f; + }; + $ptrType(StringSlice).prototype.Sort = function() { return this.$get().Sort(); }; + StringSlice.methods = [{prop: "Search", name: "Search", pkg: "", typ: $funcType([$String], [$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)}]; + StringSlice.init($String); + $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["flag"] = (function() { + var $pkg = {}, $init, errors, fmt, io, os, sort, strconv, time, boolValue, boolFlag, intValue, int64Value, uintValue, uint64Value, stringValue, float64Value, durationValue, Value, ErrorHandling, FlagSet, Flag, sliceType, ptrType, ptrType$1, ptrType$2, ptrType$3, ptrType$4, ptrType$5, ptrType$6, ptrType$7, ptrType$8, ptrType$9, sliceType$1, ptrType$10, ptrType$11, ptrType$12, ptrType$13, ptrType$14, ptrType$15, ptrType$16, sliceType$2, funcType, ptrType$17, funcType$1, mapType, x, newBoolValue, newIntValue, newInt64Value, newUintValue, newUint64Value, newStringValue, newFloat64Value, newDurationValue, sortFlags, isZeroValue, UnquoteUsage, PrintDefaults, defaultUsage, Bool, Int, Uint, String, Duration, NewFlagSet; + errors = $packages["errors"]; + fmt = $packages["fmt"]; + io = $packages["io"]; + os = $packages["os"]; + sort = $packages["sort"]; + strconv = $packages["strconv"]; + time = $packages["time"]; + boolValue = $pkg.boolValue = $newType(1, $kindBool, "flag.boolValue", "boolValue", "flag", null); + boolFlag = $pkg.boolFlag = $newType(8, $kindInterface, "flag.boolFlag", "boolFlag", "flag", null); + intValue = $pkg.intValue = $newType(4, $kindInt, "flag.intValue", "intValue", "flag", null); + int64Value = $pkg.int64Value = $newType(8, $kindInt64, "flag.int64Value", "int64Value", "flag", null); + uintValue = $pkg.uintValue = $newType(4, $kindUint, "flag.uintValue", "uintValue", "flag", null); + uint64Value = $pkg.uint64Value = $newType(8, $kindUint64, "flag.uint64Value", "uint64Value", "flag", null); + stringValue = $pkg.stringValue = $newType(8, $kindString, "flag.stringValue", "stringValue", "flag", null); + float64Value = $pkg.float64Value = $newType(8, $kindFloat64, "flag.float64Value", "float64Value", "flag", null); + durationValue = $pkg.durationValue = $newType(8, $kindInt64, "flag.durationValue", "durationValue", "flag", null); + Value = $pkg.Value = $newType(8, $kindInterface, "flag.Value", "Value", "flag", null); + ErrorHandling = $pkg.ErrorHandling = $newType(4, $kindInt, "flag.ErrorHandling", "ErrorHandling", "flag", null); + FlagSet = $pkg.FlagSet = $newType(0, $kindStruct, "flag.FlagSet", "FlagSet", "flag", function(Usage_, name_, parsed_, actual_, formal_, args_, errorHandling_, output_) { + this.$val = this; + if (arguments.length === 0) { + this.Usage = $throwNilPointerError; + this.name = ""; + this.parsed = false; + this.actual = false; + this.formal = false; + this.args = sliceType$2.nil; + this.errorHandling = 0; + this.output = $ifaceNil; + return; + } + this.Usage = Usage_; + this.name = name_; + this.parsed = parsed_; + this.actual = actual_; + this.formal = formal_; + this.args = args_; + this.errorHandling = errorHandling_; + this.output = output_; + }); + Flag = $pkg.Flag = $newType(0, $kindStruct, "flag.Flag", "Flag", "flag", function(Name_, Usage_, Value_, DefValue_) { + this.$val = this; + if (arguments.length === 0) { + this.Name = ""; + this.Usage = ""; + this.Value = $ifaceNil; + this.DefValue = ""; + return; + } + this.Name = Name_; + this.Usage = Usage_; + this.Value = Value_; + this.DefValue = DefValue_; + }); + sliceType = $sliceType($emptyInterface); + ptrType = $ptrType(boolValue); + ptrType$1 = $ptrType(intValue); + ptrType$2 = $ptrType(int64Value); + ptrType$3 = $ptrType(uintValue); + ptrType$4 = $ptrType(uint64Value); + ptrType$5 = $ptrType(stringValue); + ptrType$6 = $ptrType(float64Value); + ptrType$7 = $ptrType(durationValue); + ptrType$8 = $ptrType(time.Duration); + ptrType$9 = $ptrType(Flag); + sliceType$1 = $sliceType(ptrType$9); + ptrType$10 = $ptrType($Bool); + ptrType$11 = $ptrType($Int); + ptrType$12 = $ptrType($Int64); + ptrType$13 = $ptrType($Uint); + ptrType$14 = $ptrType($Uint64); + ptrType$15 = $ptrType($String); + ptrType$16 = $ptrType($Float64); + sliceType$2 = $sliceType($String); + funcType = $funcType([ptrType$9], [], false); + ptrType$17 = $ptrType(FlagSet); + funcType$1 = $funcType([], [], false); + mapType = $mapType($String, ptrType$9); + newBoolValue = function(val, p) { + var $ptr, _ptr, p, val; + p.$set(val); + return (_ptr = p, new ptrType(function() { return _ptr.$get(); }, function($v) { _ptr.$set($v); }, _ptr.$target)); + }; + $ptrType(boolValue).prototype.Set = function(s) { + var $ptr, _tuple, b, err, s, v; + b = this; + _tuple = strconv.ParseBool(s); + v = _tuple[0]; + err = _tuple[1]; + b.$set(v); + return err; + }; + $ptrType(boolValue).prototype.Get = function() { + var $ptr, b; + b = this; + return new $Bool(b.$get()); + }; + $ptrType(boolValue).prototype.String = function() { + var $ptr, _r, b, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; b = $f.b; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + b = this; + _r = fmt.Sprintf("%v", new sliceType([new boolValue(b.$get())])); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ $s = 2; case 2: + return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: $ptrType(boolValue).prototype.String }; } $f.$ptr = $ptr; $f._r = _r; $f.b = b; $f.$s = $s; $f.$r = $r; return $f; + }; + $ptrType(boolValue).prototype.IsBoolFlag = function() { + var $ptr, b; + b = this; + return true; + }; + newIntValue = function(val, p) { + var $ptr, _ptr, p, val; + p.$set(val); + return (_ptr = p, new ptrType$1(function() { return (_ptr.$get() >> 0); }, function($v) { _ptr.$set(($v >> 0)); }, _ptr.$target)); + }; + $ptrType(intValue).prototype.Set = function(s) { + var $ptr, _tuple, err, i, s, v; + i = this; + _tuple = strconv.ParseInt(s, 0, 64); + v = _tuple[0]; + err = _tuple[1]; + i.$set(((v.$low + ((v.$high >> 31) * 4294967296)) >> 0)); + return err; + }; + $ptrType(intValue).prototype.Get = function() { + var $ptr, i; + i = this; + return new $Int((i.$get() >> 0)); + }; + $ptrType(intValue).prototype.String = function() { + var $ptr, _r, i, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; i = $f.i; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + i = this; + _r = fmt.Sprintf("%v", new sliceType([new intValue(i.$get())])); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ $s = 2; case 2: + return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: $ptrType(intValue).prototype.String }; } $f.$ptr = $ptr; $f._r = _r; $f.i = i; $f.$s = $s; $f.$r = $r; return $f; + }; + newInt64Value = function(val, p) { + var $ptr, _ptr, p, val, x$1; + p.$set(val); + return (_ptr = p, new ptrType$2(function() { return (x$1 = _ptr.$get(), new int64Value(x$1.$high, x$1.$low)); }, function($v) { _ptr.$set(new $Int64($v.$high, $v.$low)); }, _ptr.$target)); + }; + $ptrType(int64Value).prototype.Set = function(s) { + var $ptr, _tuple, err, i, s, v; + i = this; + _tuple = strconv.ParseInt(s, 0, 64); + v = _tuple[0]; + err = _tuple[1]; + i.$set(new int64Value(v.$high, v.$low)); + return err; + }; + $ptrType(int64Value).prototype.Get = function() { + var $ptr, i, x$1; + i = this; + return (x$1 = i.$get(), new $Int64(x$1.$high, x$1.$low)); + }; + $ptrType(int64Value).prototype.String = function() { + var $ptr, _r, i, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; i = $f.i; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + i = this; + _r = fmt.Sprintf("%v", new sliceType([i.$get()])); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ $s = 2; case 2: + return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: $ptrType(int64Value).prototype.String }; } $f.$ptr = $ptr; $f._r = _r; $f.i = i; $f.$s = $s; $f.$r = $r; return $f; + }; + newUintValue = function(val, p) { + var $ptr, _ptr, p, val; + p.$set(val); + return (_ptr = p, new ptrType$3(function() { return (_ptr.$get() >>> 0); }, function($v) { _ptr.$set(($v >>> 0)); }, _ptr.$target)); + }; + $ptrType(uintValue).prototype.Set = function(s) { + var $ptr, _tuple, err, i, s, v; + i = this; + _tuple = strconv.ParseUint(s, 0, 64); + v = _tuple[0]; + err = _tuple[1]; + i.$set((v.$low >>> 0)); + return err; + }; + $ptrType(uintValue).prototype.Get = function() { + var $ptr, i; + i = this; + return new $Uint((i.$get() >>> 0)); + }; + $ptrType(uintValue).prototype.String = function() { + var $ptr, _r, i, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; i = $f.i; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + i = this; + _r = fmt.Sprintf("%v", new sliceType([new uintValue(i.$get())])); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ $s = 2; case 2: + return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: $ptrType(uintValue).prototype.String }; } $f.$ptr = $ptr; $f._r = _r; $f.i = i; $f.$s = $s; $f.$r = $r; return $f; + }; + newUint64Value = function(val, p) { + var $ptr, _ptr, p, val, x$1; + p.$set(val); + return (_ptr = p, new ptrType$4(function() { return (x$1 = _ptr.$get(), new uint64Value(x$1.$high, x$1.$low)); }, function($v) { _ptr.$set(new $Uint64($v.$high, $v.$low)); }, _ptr.$target)); + }; + $ptrType(uint64Value).prototype.Set = function(s) { + var $ptr, _tuple, err, i, s, v; + i = this; + _tuple = strconv.ParseUint(s, 0, 64); + v = _tuple[0]; + err = _tuple[1]; + i.$set(new uint64Value(v.$high, v.$low)); + return err; + }; + $ptrType(uint64Value).prototype.Get = function() { + var $ptr, i, x$1; + i = this; + return (x$1 = i.$get(), new $Uint64(x$1.$high, x$1.$low)); + }; + $ptrType(uint64Value).prototype.String = function() { + var $ptr, _r, i, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; i = $f.i; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + i = this; + _r = fmt.Sprintf("%v", new sliceType([i.$get()])); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ $s = 2; case 2: + return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: $ptrType(uint64Value).prototype.String }; } $f.$ptr = $ptr; $f._r = _r; $f.i = i; $f.$s = $s; $f.$r = $r; return $f; + }; + newStringValue = function(val, p) { + var $ptr, _ptr, p, val; + p.$set(val); + return (_ptr = p, new ptrType$5(function() { return _ptr.$get(); }, function($v) { _ptr.$set($v); }, _ptr.$target)); + }; + $ptrType(stringValue).prototype.Set = function(val) { + var $ptr, s, val; + s = this; + s.$set(val); + return $ifaceNil; + }; + $ptrType(stringValue).prototype.Get = function() { + var $ptr, s; + s = this; + return new $String(s.$get()); + }; + $ptrType(stringValue).prototype.String = function() { + var $ptr, _r, s, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + s = this; + _r = fmt.Sprintf("%s", new sliceType([new stringValue(s.$get())])); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ $s = 2; case 2: + return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: $ptrType(stringValue).prototype.String }; } $f.$ptr = $ptr; $f._r = _r; $f.s = s; $f.$s = $s; $f.$r = $r; return $f; + }; + newFloat64Value = function(val, p) { + var $ptr, _ptr, p, val; + p.$set(val); + return (_ptr = p, new ptrType$6(function() { return _ptr.$get(); }, function($v) { _ptr.$set($v); }, _ptr.$target)); + }; + $ptrType(float64Value).prototype.Set = function(s) { + var $ptr, _tuple, err, f, s, v; + f = this; + _tuple = strconv.ParseFloat(s, 64); + v = _tuple[0]; + err = _tuple[1]; + f.$set(v); + return err; + }; + $ptrType(float64Value).prototype.Get = function() { + var $ptr, f; + f = this; + return new $Float64(f.$get()); + }; + $ptrType(float64Value).prototype.String = function() { + var $ptr, _r, f, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; f = $f.f; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = this; + _r = fmt.Sprintf("%v", new sliceType([new float64Value(f.$get())])); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ $s = 2; case 2: + return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: $ptrType(float64Value).prototype.String }; } $f.$ptr = $ptr; $f._r = _r; $f.f = f; $f.$s = $s; $f.$r = $r; return $f; + }; + newDurationValue = function(val, p) { + var $ptr, _ptr, p, val, x$1; + p.$set(val); + return (_ptr = p, new ptrType$7(function() { return (x$1 = _ptr.$get(), new durationValue(x$1.$high, x$1.$low)); }, function($v) { _ptr.$set(new time.Duration($v.$high, $v.$low)); }, _ptr.$target)); + }; + $ptrType(durationValue).prototype.Set = function(s) { + var $ptr, _tuple, d, err, s, v; + d = this; + _tuple = time.ParseDuration(s); + v = _tuple[0]; + err = _tuple[1]; + d.$set(new durationValue(v.$high, v.$low)); + return err; + }; + $ptrType(durationValue).prototype.Get = function() { + var $ptr, d, x$1; + d = this; + return (x$1 = d.$get(), new time.Duration(x$1.$high, x$1.$low)); + }; + $ptrType(durationValue).prototype.String = function() { + var $ptr, _ptr, d, x$1; + d = this; + return (_ptr = d, new ptrType$8(function() { return (x$1 = _ptr.$get(), new time.Duration(x$1.$high, x$1.$low)); }, function($v) { _ptr.$set(new durationValue($v.$high, $v.$low)); }, _ptr.$target)).String(); + }; + sortFlags = function(flags) { + var $ptr, _entry, _entry$1, _i, _i$1, _keys, _ref, _ref$1, f, flags, i, i$1, list, name, result, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _entry$1 = $f._entry$1; _i = $f._i; _i$1 = $f._i$1; _keys = $f._keys; _ref = $f._ref; _ref$1 = $f._ref$1; f = $f.f; flags = $f.flags; i = $f.i; i$1 = $f.i$1; list = $f.list; name = $f.name; result = $f.result; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + list = $makeSlice(sort.StringSlice, $keys(flags).length); + i = 0; + _ref = flags; + _i = 0; + _keys = $keys(_ref); + while (true) { + if (!(_i < _keys.length)) { break; } + _entry = _ref[_keys[_i]]; + if (_entry === undefined) { + _i++; + continue; + } + f = _entry.v; + ((i < 0 || i >= list.$length) ? $throwRuntimeError("index out of range") : list.$array[list.$offset + i] = f.Name); + i = i + (1) >> 0; + _i++; + } + $r = list.Sort(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + result = $makeSlice(sliceType$1, list.$length); + _ref$1 = list; + _i$1 = 0; + while (true) { + if (!(_i$1 < _ref$1.$length)) { break; } + i$1 = _i$1; + name = ((_i$1 < 0 || _i$1 >= _ref$1.$length) ? $throwRuntimeError("index out of range") : _ref$1.$array[_ref$1.$offset + _i$1]); + ((i$1 < 0 || i$1 >= result.$length) ? $throwRuntimeError("index out of range") : result.$array[result.$offset + i$1] = (_entry$1 = flags[$String.keyFor(name)], _entry$1 !== undefined ? _entry$1.v : ptrType$9.nil)); + _i$1++; + } + return result; + /* */ } return; } if ($f === undefined) { $f = { $blk: sortFlags }; } $f.$ptr = $ptr; $f._entry = _entry; $f._entry$1 = _entry$1; $f._i = _i; $f._i$1 = _i$1; $f._keys = _keys; $f._ref = _ref; $f._ref$1 = _ref$1; $f.f = f; $f.flags = flags; $f.i = i; $f.i$1 = i$1; $f.list = list; $f.name = name; $f.result = result; $f.$s = $s; $f.$r = $r; return $f; + }; + FlagSet.ptr.prototype.out = function() { + var $ptr, f; + f = this; + if ($interfaceIsEqual(f.output, $ifaceNil)) { + return os.Stderr; + } + return f.output; + }; + FlagSet.prototype.out = function() { return this.$val.out(); }; + FlagSet.ptr.prototype.SetOutput = function(output) { + var $ptr, f, output; + f = this; + f.output = output; + }; + FlagSet.prototype.SetOutput = function(output) { return this.$val.SetOutput(output); }; + FlagSet.ptr.prototype.VisitAll = function(fn) { + var $ptr, _i, _r, _ref, f, flag, fn, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r = $f._r; _ref = $f._ref; f = $f.f; flag = $f.flag; fn = $f.fn; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = this; + _r = sortFlags(f.formal); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _ref = _r; + _i = 0; + /* while (true) { */ case 2: + /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 3; continue; } + flag = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]); + $r = fn(flag); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + _i++; + /* } */ $s = 2; continue; case 3: + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: FlagSet.ptr.prototype.VisitAll }; } $f.$ptr = $ptr; $f._i = _i; $f._r = _r; $f._ref = _ref; $f.f = f; $f.flag = flag; $f.fn = fn; $f.$s = $s; $f.$r = $r; return $f; + }; + FlagSet.prototype.VisitAll = function(fn) { return this.$val.VisitAll(fn); }; + FlagSet.ptr.prototype.Visit = function(fn) { + var $ptr, _i, _r, _ref, f, flag, fn, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r = $f._r; _ref = $f._ref; f = $f.f; flag = $f.flag; fn = $f.fn; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = this; + _r = sortFlags(f.actual); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _ref = _r; + _i = 0; + /* while (true) { */ case 2: + /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 3; continue; } + flag = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]); + $r = fn(flag); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + _i++; + /* } */ $s = 2; continue; case 3: + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: FlagSet.ptr.prototype.Visit }; } $f.$ptr = $ptr; $f._i = _i; $f._r = _r; $f._ref = _ref; $f.f = f; $f.flag = flag; $f.fn = fn; $f.$s = $s; $f.$r = $r; return $f; + }; + FlagSet.prototype.Visit = function(fn) { return this.$val.Visit(fn); }; + FlagSet.ptr.prototype.Lookup = function(name) { + var $ptr, _entry, f, name; + f = this; + return (_entry = f.formal[$String.keyFor(name)], _entry !== undefined ? _entry.v : ptrType$9.nil); + }; + FlagSet.prototype.Lookup = function(name) { return this.$val.Lookup(name); }; + FlagSet.ptr.prototype.Set = function(name, value) { + var $ptr, _entry, _key, _r, _r$1, _tuple, err, f, flag, name, ok, value, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _key = $f._key; _r = $f._r; _r$1 = $f._r$1; _tuple = $f._tuple; err = $f.err; f = $f.f; flag = $f.flag; name = $f.name; ok = $f.ok; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = this; + _tuple = (_entry = f.formal[$String.keyFor(name)], _entry !== undefined ? [_entry.v, true] : [ptrType$9.nil, false]); + flag = _tuple[0]; + ok = _tuple[1]; + /* */ if (!ok) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (!ok) { */ case 1: + _r = fmt.Errorf("no such flag -%v", new sliceType([new $String(name)])); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ $s = 4; case 4: + return _r; + /* } */ case 2: + _r$1 = flag.Value.Set(value); /* */ $s = 5; case 5: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + err = _r$1; + if (!($interfaceIsEqual(err, $ifaceNil))) { + return err; + } + if (f.actual === false) { + f.actual = {}; + } + _key = name; (f.actual || $throwRuntimeError("assignment to entry in nil map"))[$String.keyFor(_key)] = { k: _key, v: flag }; + return $ifaceNil; + /* */ } return; } if ($f === undefined) { $f = { $blk: FlagSet.ptr.prototype.Set }; } $f.$ptr = $ptr; $f._entry = _entry; $f._key = _key; $f._r = _r; $f._r$1 = _r$1; $f._tuple = _tuple; $f.err = err; $f.f = f; $f.flag = flag; $f.name = name; $f.ok = ok; $f.value = value; $f.$s = $s; $f.$r = $r; return $f; + }; + FlagSet.prototype.Set = function(name, value) { return this.$val.Set(name, value); }; + isZeroValue = function(value) { + var $ptr, _1, value; + _1 = value; + if (_1 === ("false")) { + return true; + } else if (_1 === ("")) { + return true; + } else if (_1 === ("0")) { + return true; + } + return false; + }; + UnquoteUsage = function(flag) { + var $ptr, _ref, _tmp, _tmp$1, flag, i, j, name, usage; + name = ""; + usage = ""; + usage = flag.Usage; + i = 0; + while (true) { + if (!(i < usage.length)) { break; } + if (usage.charCodeAt(i) === 96) { + j = i + 1 >> 0; + while (true) { + if (!(j < usage.length)) { break; } + if (usage.charCodeAt(j) === 96) { + name = usage.substring((i + 1 >> 0), j); + usage = usage.substring(0, i) + name + usage.substring((j + 1 >> 0)); + _tmp = name; + _tmp$1 = usage; + name = _tmp; + usage = _tmp$1; + return [name, usage]; + } + j = j + (1) >> 0; + } + break; + } + i = i + (1) >> 0; + } + name = "value"; + _ref = flag.Value; + if ($assertType(_ref, boolFlag, true)[1]) { + name = ""; + } else if ($assertType(_ref, ptrType$7, true)[1]) { + name = "duration"; + } else if ($assertType(_ref, ptrType$6, true)[1]) { + name = "float"; + } else if ($assertType(_ref, ptrType$1, true)[1] || $assertType(_ref, ptrType$2, true)[1]) { + name = "int"; + } else if ($assertType(_ref, ptrType$5, true)[1]) { + name = "string"; + } else if ($assertType(_ref, ptrType$3, true)[1] || $assertType(_ref, ptrType$4, true)[1]) { + name = "uint"; + } + return [name, usage]; + }; + $pkg.UnquoteUsage = UnquoteUsage; + FlagSet.ptr.prototype.PrintDefaults = function() { + var $ptr, f, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; f = $f.f; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = [f]; + f[0] = this; + $r = f[0].VisitAll((function(f) { return function $b(flag) { + var $ptr, _r, _r$1, _r$2, _r$3, _tuple, _tuple$1, flag, name, ok, s, usage, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; flag = $f.flag; name = $f.name; ok = $f.ok; s = $f.s; usage = $f.usage; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = fmt.Sprintf(" -%s", new sliceType([new $String(flag.Name)])); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + s = _r; + _tuple = UnquoteUsage(flag); + name = _tuple[0]; + usage = _tuple[1]; + if (name.length > 0) { + s = s + (" " + name); + } + if (s.length <= 4) { + s = s + ("\t"); + } else { + s = s + ("\n \t"); + } + s = s + (usage); + /* */ if (!isZeroValue(flag.DefValue)) { $s = 2; continue; } + /* */ $s = 3; continue; + /* if (!isZeroValue(flag.DefValue)) { */ case 2: + _tuple$1 = $assertType(flag.Value, ptrType$5, true); + ok = _tuple$1[1]; + /* */ if (ok) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (ok) { */ case 4: + _r$1 = fmt.Sprintf(" (default %q)", new sliceType([new $String(flag.DefValue)])); /* */ $s = 7; case 7: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + s = s + (_r$1); + $s = 6; continue; + /* } else { */ case 5: + _r$2 = fmt.Sprintf(" (default %v)", new sliceType([new $String(flag.DefValue)])); /* */ $s = 8; case 8: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + s = s + (_r$2); + /* } */ case 6: + /* } */ case 3: + _r$3 = fmt.Fprint(f[0].out(), new sliceType([new $String(s), new $String("\n")])); /* */ $s = 9; case 9: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _r$3; + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f.flag = flag; $f.name = name; $f.ok = ok; $f.s = s; $f.usage = usage; $f.$s = $s; $f.$r = $r; return $f; + }; })(f)); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: FlagSet.ptr.prototype.PrintDefaults }; } $f.$ptr = $ptr; $f.f = f; $f.$s = $s; $f.$r = $r; return $f; + }; + FlagSet.prototype.PrintDefaults = function() { return this.$val.PrintDefaults(); }; + PrintDefaults = function() { + var $ptr, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + $r = $pkg.CommandLine.PrintDefaults(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: PrintDefaults }; } $f.$ptr = $ptr; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.PrintDefaults = PrintDefaults; + defaultUsage = function(f) { + var $ptr, _r, _r$1, f, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; f = $f.f; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + /* */ if (f.name === "") { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (f.name === "") { */ case 1: + _r = fmt.Fprintf(f.out(), "Usage:\n", new sliceType([])); /* */ $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 = fmt.Fprintf(f.out(), "Usage of %s:\n", new sliceType([new $String(f.name)])); /* */ $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: + $r = f.PrintDefaults(); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: defaultUsage }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f.f = f; $f.$s = $s; $f.$r = $r; return $f; + }; + FlagSet.ptr.prototype.NFlag = function() { + var $ptr, f; + f = this; + return $keys(f.actual).length; + }; + FlagSet.prototype.NFlag = function() { return this.$val.NFlag(); }; + FlagSet.ptr.prototype.Arg = function(i) { + var $ptr, f, i, x$1; + f = this; + if (i < 0 || i >= f.args.$length) { + return ""; + } + return (x$1 = f.args, ((i < 0 || i >= x$1.$length) ? $throwRuntimeError("index out of range") : x$1.$array[x$1.$offset + i])); + }; + FlagSet.prototype.Arg = function(i) { return this.$val.Arg(i); }; + FlagSet.ptr.prototype.NArg = function() { + var $ptr, f; + f = this; + return f.args.$length; + }; + FlagSet.prototype.NArg = function() { return this.$val.NArg(); }; + FlagSet.ptr.prototype.Args = function() { + var $ptr, f; + f = this; + return f.args; + }; + FlagSet.prototype.Args = function() { return this.$val.Args(); }; + FlagSet.ptr.prototype.BoolVar = function(p, name, value, usage) { + var $ptr, f, name, p, usage, value, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; f = $f.f; name = $f.name; p = $f.p; usage = $f.usage; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = this; + $r = f.Var(newBoolValue(value, p), name, usage); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: FlagSet.ptr.prototype.BoolVar }; } $f.$ptr = $ptr; $f.f = f; $f.name = name; $f.p = p; $f.usage = usage; $f.value = value; $f.$s = $s; $f.$r = $r; return $f; + }; + FlagSet.prototype.BoolVar = function(p, name, value, usage) { return this.$val.BoolVar(p, name, value, usage); }; + FlagSet.ptr.prototype.Bool = function(name, value, usage) { + var $ptr, f, name, p, usage, value, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; f = $f.f; name = $f.name; p = $f.p; usage = $f.usage; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = this; + p = $newDataPointer(false, ptrType$10); + $r = f.BoolVar(p, name, value, usage); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + return p; + /* */ } return; } if ($f === undefined) { $f = { $blk: FlagSet.ptr.prototype.Bool }; } $f.$ptr = $ptr; $f.f = f; $f.name = name; $f.p = p; $f.usage = usage; $f.value = value; $f.$s = $s; $f.$r = $r; return $f; + }; + FlagSet.prototype.Bool = function(name, value, usage) { return this.$val.Bool(name, value, usage); }; + Bool = function(name, value, usage) { + var $ptr, _r, name, usage, value, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; name = $f.name; usage = $f.usage; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = $pkg.CommandLine.Bool(name, value, usage); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ $s = 2; case 2: + return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: Bool }; } $f.$ptr = $ptr; $f._r = _r; $f.name = name; $f.usage = usage; $f.value = value; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.Bool = Bool; + FlagSet.ptr.prototype.IntVar = function(p, name, value, usage) { + var $ptr, f, name, p, usage, value, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; f = $f.f; name = $f.name; p = $f.p; usage = $f.usage; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = this; + $r = f.Var(newIntValue(value, p), name, usage); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: FlagSet.ptr.prototype.IntVar }; } $f.$ptr = $ptr; $f.f = f; $f.name = name; $f.p = p; $f.usage = usage; $f.value = value; $f.$s = $s; $f.$r = $r; return $f; + }; + FlagSet.prototype.IntVar = function(p, name, value, usage) { return this.$val.IntVar(p, name, value, usage); }; + FlagSet.ptr.prototype.Int = function(name, value, usage) { + var $ptr, f, name, p, usage, value, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; f = $f.f; name = $f.name; p = $f.p; usage = $f.usage; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = this; + p = $newDataPointer(0, ptrType$11); + $r = f.IntVar(p, name, value, usage); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + return p; + /* */ } return; } if ($f === undefined) { $f = { $blk: FlagSet.ptr.prototype.Int }; } $f.$ptr = $ptr; $f.f = f; $f.name = name; $f.p = p; $f.usage = usage; $f.value = value; $f.$s = $s; $f.$r = $r; return $f; + }; + FlagSet.prototype.Int = function(name, value, usage) { return this.$val.Int(name, value, usage); }; + Int = function(name, value, usage) { + var $ptr, _r, name, usage, value, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; name = $f.name; usage = $f.usage; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = $pkg.CommandLine.Int(name, value, usage); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ $s = 2; case 2: + return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: Int }; } $f.$ptr = $ptr; $f._r = _r; $f.name = name; $f.usage = usage; $f.value = value; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.Int = Int; + FlagSet.ptr.prototype.Int64Var = function(p, name, value, usage) { + var $ptr, f, name, p, usage, value, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; f = $f.f; name = $f.name; p = $f.p; usage = $f.usage; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = this; + $r = f.Var(newInt64Value(value, p), name, usage); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: FlagSet.ptr.prototype.Int64Var }; } $f.$ptr = $ptr; $f.f = f; $f.name = name; $f.p = p; $f.usage = usage; $f.value = value; $f.$s = $s; $f.$r = $r; return $f; + }; + FlagSet.prototype.Int64Var = function(p, name, value, usage) { return this.$val.Int64Var(p, name, value, usage); }; + FlagSet.ptr.prototype.Int64 = function(name, value, usage) { + var $ptr, f, name, p, usage, value, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; f = $f.f; name = $f.name; p = $f.p; usage = $f.usage; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = this; + p = $newDataPointer(new $Int64(0, 0), ptrType$12); + $r = f.Int64Var(p, name, value, usage); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + return p; + /* */ } return; } if ($f === undefined) { $f = { $blk: FlagSet.ptr.prototype.Int64 }; } $f.$ptr = $ptr; $f.f = f; $f.name = name; $f.p = p; $f.usage = usage; $f.value = value; $f.$s = $s; $f.$r = $r; return $f; + }; + FlagSet.prototype.Int64 = function(name, value, usage) { return this.$val.Int64(name, value, usage); }; + FlagSet.ptr.prototype.UintVar = function(p, name, value, usage) { + var $ptr, f, name, p, usage, value, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; f = $f.f; name = $f.name; p = $f.p; usage = $f.usage; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = this; + $r = f.Var(newUintValue(value, p), name, usage); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: FlagSet.ptr.prototype.UintVar }; } $f.$ptr = $ptr; $f.f = f; $f.name = name; $f.p = p; $f.usage = usage; $f.value = value; $f.$s = $s; $f.$r = $r; return $f; + }; + FlagSet.prototype.UintVar = function(p, name, value, usage) { return this.$val.UintVar(p, name, value, usage); }; + FlagSet.ptr.prototype.Uint = function(name, value, usage) { + var $ptr, f, name, p, usage, value, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; f = $f.f; name = $f.name; p = $f.p; usage = $f.usage; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = this; + p = $newDataPointer(0, ptrType$13); + $r = f.UintVar(p, name, value, usage); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + return p; + /* */ } return; } if ($f === undefined) { $f = { $blk: FlagSet.ptr.prototype.Uint }; } $f.$ptr = $ptr; $f.f = f; $f.name = name; $f.p = p; $f.usage = usage; $f.value = value; $f.$s = $s; $f.$r = $r; return $f; + }; + FlagSet.prototype.Uint = function(name, value, usage) { return this.$val.Uint(name, value, usage); }; + Uint = function(name, value, usage) { + var $ptr, _r, name, usage, value, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; name = $f.name; usage = $f.usage; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = $pkg.CommandLine.Uint(name, value, usage); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ $s = 2; case 2: + return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: Uint }; } $f.$ptr = $ptr; $f._r = _r; $f.name = name; $f.usage = usage; $f.value = value; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.Uint = Uint; + FlagSet.ptr.prototype.Uint64Var = function(p, name, value, usage) { + var $ptr, f, name, p, usage, value, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; f = $f.f; name = $f.name; p = $f.p; usage = $f.usage; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = this; + $r = f.Var(newUint64Value(value, p), name, usage); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: FlagSet.ptr.prototype.Uint64Var }; } $f.$ptr = $ptr; $f.f = f; $f.name = name; $f.p = p; $f.usage = usage; $f.value = value; $f.$s = $s; $f.$r = $r; return $f; + }; + FlagSet.prototype.Uint64Var = function(p, name, value, usage) { return this.$val.Uint64Var(p, name, value, usage); }; + FlagSet.ptr.prototype.Uint64 = function(name, value, usage) { + var $ptr, f, name, p, usage, value, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; f = $f.f; name = $f.name; p = $f.p; usage = $f.usage; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = this; + p = $newDataPointer(new $Uint64(0, 0), ptrType$14); + $r = f.Uint64Var(p, name, value, usage); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + return p; + /* */ } return; } if ($f === undefined) { $f = { $blk: FlagSet.ptr.prototype.Uint64 }; } $f.$ptr = $ptr; $f.f = f; $f.name = name; $f.p = p; $f.usage = usage; $f.value = value; $f.$s = $s; $f.$r = $r; return $f; + }; + FlagSet.prototype.Uint64 = function(name, value, usage) { return this.$val.Uint64(name, value, usage); }; + FlagSet.ptr.prototype.StringVar = function(p, name, value, usage) { + var $ptr, f, name, p, usage, value, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; f = $f.f; name = $f.name; p = $f.p; usage = $f.usage; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = this; + $r = f.Var(newStringValue(value, p), name, usage); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: FlagSet.ptr.prototype.StringVar }; } $f.$ptr = $ptr; $f.f = f; $f.name = name; $f.p = p; $f.usage = usage; $f.value = value; $f.$s = $s; $f.$r = $r; return $f; + }; + FlagSet.prototype.StringVar = function(p, name, value, usage) { return this.$val.StringVar(p, name, value, usage); }; + FlagSet.ptr.prototype.String = function(name, value, usage) { + var $ptr, f, name, p, usage, value, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; f = $f.f; name = $f.name; p = $f.p; usage = $f.usage; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = this; + p = $newDataPointer("", ptrType$15); + $r = f.StringVar(p, name, value, usage); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + return p; + /* */ } return; } if ($f === undefined) { $f = { $blk: FlagSet.ptr.prototype.String }; } $f.$ptr = $ptr; $f.f = f; $f.name = name; $f.p = p; $f.usage = usage; $f.value = value; $f.$s = $s; $f.$r = $r; return $f; + }; + FlagSet.prototype.String = function(name, value, usage) { return this.$val.String(name, value, usage); }; + String = function(name, value, usage) { + var $ptr, _r, name, usage, value, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; name = $f.name; usage = $f.usage; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = $pkg.CommandLine.String(name, value, usage); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ $s = 2; case 2: + return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: String }; } $f.$ptr = $ptr; $f._r = _r; $f.name = name; $f.usage = usage; $f.value = value; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.String = String; + FlagSet.ptr.prototype.Float64Var = function(p, name, value, usage) { + var $ptr, f, name, p, usage, value, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; f = $f.f; name = $f.name; p = $f.p; usage = $f.usage; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = this; + $r = f.Var(newFloat64Value(value, p), name, usage); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: FlagSet.ptr.prototype.Float64Var }; } $f.$ptr = $ptr; $f.f = f; $f.name = name; $f.p = p; $f.usage = usage; $f.value = value; $f.$s = $s; $f.$r = $r; return $f; + }; + FlagSet.prototype.Float64Var = function(p, name, value, usage) { return this.$val.Float64Var(p, name, value, usage); }; + FlagSet.ptr.prototype.Float64 = function(name, value, usage) { + var $ptr, f, name, p, usage, value, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; f = $f.f; name = $f.name; p = $f.p; usage = $f.usage; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = this; + p = $newDataPointer(0, ptrType$16); + $r = f.Float64Var(p, name, value, usage); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + return p; + /* */ } return; } if ($f === undefined) { $f = { $blk: FlagSet.ptr.prototype.Float64 }; } $f.$ptr = $ptr; $f.f = f; $f.name = name; $f.p = p; $f.usage = usage; $f.value = value; $f.$s = $s; $f.$r = $r; return $f; + }; + FlagSet.prototype.Float64 = function(name, value, usage) { return this.$val.Float64(name, value, usage); }; + FlagSet.ptr.prototype.DurationVar = function(p, name, value, usage) { + var $ptr, f, name, p, usage, value, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; f = $f.f; name = $f.name; p = $f.p; usage = $f.usage; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = this; + $r = f.Var(newDurationValue(value, p), name, usage); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: FlagSet.ptr.prototype.DurationVar }; } $f.$ptr = $ptr; $f.f = f; $f.name = name; $f.p = p; $f.usage = usage; $f.value = value; $f.$s = $s; $f.$r = $r; return $f; + }; + FlagSet.prototype.DurationVar = function(p, name, value, usage) { return this.$val.DurationVar(p, name, value, usage); }; + FlagSet.ptr.prototype.Duration = function(name, value, usage) { + var $ptr, f, name, p, usage, value, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; f = $f.f; name = $f.name; p = $f.p; usage = $f.usage; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = this; + p = $newDataPointer(new time.Duration(0, 0), ptrType$8); + $r = f.DurationVar(p, name, value, usage); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + return p; + /* */ } return; } if ($f === undefined) { $f = { $blk: FlagSet.ptr.prototype.Duration }; } $f.$ptr = $ptr; $f.f = f; $f.name = name; $f.p = p; $f.usage = usage; $f.value = value; $f.$s = $s; $f.$r = $r; return $f; + }; + FlagSet.prototype.Duration = function(name, value, usage) { return this.$val.Duration(name, value, usage); }; + Duration = function(name, value, usage) { + var $ptr, _r, name, usage, value, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; name = $f.name; usage = $f.usage; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = $pkg.CommandLine.Duration(name, value, usage); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ $s = 2; case 2: + return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: Duration }; } $f.$ptr = $ptr; $f._r = _r; $f.name = name; $f.usage = usage; $f.value = value; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.Duration = Duration; + FlagSet.ptr.prototype.Var = function(value, name, usage) { + var $ptr, _entry, _key, _r, _r$1, _r$2, _r$3, _tuple, alreadythere, f, flag, msg, name, usage, value, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _key = $f._key; _r = $f._r; _r$1 = $f._r$1; _r$2 = $f._r$2; _r$3 = $f._r$3; _tuple = $f._tuple; alreadythere = $f.alreadythere; f = $f.f; flag = $f.flag; msg = $f.msg; name = $f.name; usage = $f.usage; value = $f.value; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = this; + _r = value.String(); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + flag = new Flag.ptr(name, usage, value, _r); + _tuple = (_entry = f.formal[$String.keyFor(name)], _entry !== undefined ? [_entry.v, true] : [ptrType$9.nil, false]); + alreadythere = _tuple[1]; + /* */ if (alreadythere) { $s = 2; continue; } + /* */ $s = 3; continue; + /* if (alreadythere) { */ case 2: + msg = ""; + /* */ if (f.name === "") { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (f.name === "") { */ case 4: + _r$1 = fmt.Sprintf("flag redefined: %s", new sliceType([new $String(name)])); /* */ $s = 7; case 7: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + msg = _r$1; + $s = 6; continue; + /* } else { */ case 5: + _r$2 = fmt.Sprintf("%s flag redefined: %s", new sliceType([new $String(f.name), new $String(name)])); /* */ $s = 8; case 8: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + msg = _r$2; + /* } */ case 6: + _r$3 = fmt.Fprintln(f.out(), new sliceType([new $String(msg)])); /* */ $s = 9; case 9: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _r$3; + $panic(new $String(msg)); + /* } */ case 3: + if (f.formal === false) { + f.formal = {}; + } + _key = name; (f.formal || $throwRuntimeError("assignment to entry in nil map"))[$String.keyFor(_key)] = { k: _key, v: flag }; + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: FlagSet.ptr.prototype.Var }; } $f.$ptr = $ptr; $f._entry = _entry; $f._key = _key; $f._r = _r; $f._r$1 = _r$1; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._tuple = _tuple; $f.alreadythere = alreadythere; $f.f = f; $f.flag = flag; $f.msg = msg; $f.name = name; $f.usage = usage; $f.value = value; $f.$s = $s; $f.$r = $r; return $f; + }; + FlagSet.prototype.Var = function(value, name, usage) { return this.$val.Var(value, name, usage); }; + FlagSet.ptr.prototype.failf = function(format, a) { + var $ptr, _r, _r$1, a, err, f, format, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _r$1 = $f._r$1; a = $f.a; err = $f.err; f = $f.f; format = $f.format; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = this; + _r = fmt.Errorf(format, a); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + err = _r; + _r$1 = fmt.Fprintln(f.out(), new sliceType([err])); /* */ $s = 2; case 2: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + _r$1; + $r = f.usage(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + return err; + /* */ } return; } if ($f === undefined) { $f = { $blk: FlagSet.ptr.prototype.failf }; } $f.$ptr = $ptr; $f._r = _r; $f._r$1 = _r$1; $f.a = a; $f.err = err; $f.f = f; $f.format = format; $f.$s = $s; $f.$r = $r; return $f; + }; + FlagSet.prototype.failf = function(format, a) { return this.$val.failf(format, a); }; + FlagSet.ptr.prototype.usage = function() { + var $ptr, f, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; f = $f.f; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = this; + /* */ if (f.Usage === $throwNilPointerError) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (f.Usage === $throwNilPointerError) { */ case 1: + /* */ if (f === $pkg.CommandLine) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (f === $pkg.CommandLine) { */ case 4: + $r = $pkg.Usage(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $s = 6; continue; + /* } else { */ case 5: + $r = defaultUsage(f); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 6: + $s = 3; continue; + /* } else { */ case 2: + $r = f.Usage(); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 3: + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: FlagSet.ptr.prototype.usage }; } $f.$ptr = $ptr; $f.f = f; $f.$s = $s; $f.$r = $r; return $f; + }; + FlagSet.prototype.usage = function() { return this.$val.usage(); }; + FlagSet.ptr.prototype.parseOne = function() { + var $ptr, _entry, _key, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _tmp, _tmp$1, _tuple, _tuple$1, _v, alreadythere, err, err$1, err$2, f, flag, fv, hasValue, i, m, name, numMinuses, ok, s, value, x$1, x$2, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _key = $f._key; _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; _tmp = $f._tmp; _tmp$1 = $f._tmp$1; _tuple = $f._tuple; _tuple$1 = $f._tuple$1; _v = $f._v; alreadythere = $f.alreadythere; err = $f.err; err$1 = $f.err$1; err$2 = $f.err$2; f = $f.f; flag = $f.flag; fv = $f.fv; hasValue = $f.hasValue; i = $f.i; m = $f.m; name = $f.name; numMinuses = $f.numMinuses; ok = $f.ok; s = $f.s; value = $f.value; x$1 = $f.x$1; x$2 = $f.x$2; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = this; + if (f.args.$length === 0) { + return [false, $ifaceNil]; + } + s = (x$1 = f.args, (0 >= x$1.$length ? $throwRuntimeError("index out of range") : x$1.$array[x$1.$offset + 0])); + if ((s.length === 0) || !((s.charCodeAt(0) === 45)) || (s.length === 1)) { + return [false, $ifaceNil]; + } + numMinuses = 1; + if (s.charCodeAt(1) === 45) { + numMinuses = numMinuses + (1) >> 0; + if (s.length === 2) { + f.args = $subslice(f.args, 1); + return [false, $ifaceNil]; + } + } + name = s.substring(numMinuses); + /* */ if ((name.length === 0) || (name.charCodeAt(0) === 45) || (name.charCodeAt(0) === 61)) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if ((name.length === 0) || (name.charCodeAt(0) === 45) || (name.charCodeAt(0) === 61)) { */ case 1: + _r = f.failf("bad flag syntax: %s", new sliceType([new $String(s)])); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ $s = 4; case 4: + return [false, _r]; + /* } */ case 2: + f.args = $subslice(f.args, 1); + hasValue = false; + value = ""; + i = 1; + while (true) { + if (!(i < name.length)) { break; } + if (name.charCodeAt(i) === 61) { + value = name.substring((i + 1 >> 0)); + hasValue = true; + name = name.substring(0, i); + break; + } + i = i + (1) >> 0; + } + m = f.formal; + _tuple = (_entry = m[$String.keyFor(name)], _entry !== undefined ? [_entry.v, true] : [ptrType$9.nil, false]); + flag = _tuple[0]; + alreadythere = _tuple[1]; + /* */ if (!alreadythere) { $s = 5; continue; } + /* */ $s = 6; continue; + /* if (!alreadythere) { */ case 5: + /* */ if (name === "help" || name === "h") { $s = 7; continue; } + /* */ $s = 8; continue; + /* if (name === "help" || name === "h") { */ case 7: + $r = f.usage(); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + return [false, $pkg.ErrHelp]; + /* } */ case 8: + _r$1 = f.failf("flag provided but not defined: -%s", new sliceType([new $String(name)])); /* */ $s = 10; case 10: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + /* */ $s = 11; case 11: + return [false, _r$1]; + /* } */ case 6: + _tuple$1 = $assertType(flag.Value, boolFlag, true); + fv = _tuple$1[0]; + ok = _tuple$1[1]; + if (!(ok)) { _v = false; $s = 15; continue s; } + _r$2 = fv.IsBoolFlag(); /* */ $s = 16; case 16: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _v = _r$2; case 15: + /* */ if (_v) { $s = 12; continue; } + /* */ $s = 13; continue; + /* if (_v) { */ case 12: + /* */ if (hasValue) { $s = 17; continue; } + /* */ $s = 18; continue; + /* if (hasValue) { */ case 17: + _r$3 = fv.Set(value); /* */ $s = 20; case 20: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + err = _r$3; + /* */ if (!($interfaceIsEqual(err, $ifaceNil))) { $s = 21; continue; } + /* */ $s = 22; continue; + /* if (!($interfaceIsEqual(err, $ifaceNil))) { */ case 21: + _r$4 = f.failf("invalid boolean value %q for -%s: %v", new sliceType([new $String(value), new $String(name), err])); /* */ $s = 23; case 23: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + /* */ $s = 24; case 24: + return [false, _r$4]; + /* } */ case 22: + $s = 19; continue; + /* } else { */ case 18: + _r$5 = fv.Set("true"); /* */ $s = 25; case 25: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + err$1 = _r$5; + /* */ if (!($interfaceIsEqual(err$1, $ifaceNil))) { $s = 26; continue; } + /* */ $s = 27; continue; + /* if (!($interfaceIsEqual(err$1, $ifaceNil))) { */ case 26: + _r$6 = f.failf("invalid boolean flag %s: %v", new sliceType([new $String(name), err$1])); /* */ $s = 28; case 28: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + /* */ $s = 29; case 29: + return [false, _r$6]; + /* } */ case 27: + /* } */ case 19: + $s = 14; continue; + /* } else { */ case 13: + if (!hasValue && f.args.$length > 0) { + hasValue = true; + _tmp = (x$2 = f.args, (0 >= x$2.$length ? $throwRuntimeError("index out of range") : x$2.$array[x$2.$offset + 0])); + _tmp$1 = $subslice(f.args, 1); + value = _tmp; + f.args = _tmp$1; + } + /* */ if (!hasValue) { $s = 30; continue; } + /* */ $s = 31; continue; + /* if (!hasValue) { */ case 30: + _r$7 = f.failf("flag needs an argument: -%s", new sliceType([new $String(name)])); /* */ $s = 32; case 32: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } + /* */ $s = 33; case 33: + return [false, _r$7]; + /* } */ case 31: + _r$8 = flag.Value.Set(value); /* */ $s = 34; case 34: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; } + err$2 = _r$8; + /* */ if (!($interfaceIsEqual(err$2, $ifaceNil))) { $s = 35; continue; } + /* */ $s = 36; continue; + /* if (!($interfaceIsEqual(err$2, $ifaceNil))) { */ case 35: + _r$9 = f.failf("invalid value %q for flag -%s: %v", new sliceType([new $String(value), new $String(name), err$2])); /* */ $s = 37; case 37: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; } + /* */ $s = 38; case 38: + return [false, _r$9]; + /* } */ case 36: + /* } */ case 14: + if (f.actual === false) { + f.actual = {}; + } + _key = name; (f.actual || $throwRuntimeError("assignment to entry in nil map"))[$String.keyFor(_key)] = { k: _key, v: flag }; + return [true, $ifaceNil]; + /* */ } return; } if ($f === undefined) { $f = { $blk: FlagSet.ptr.prototype.parseOne }; } $f.$ptr = $ptr; $f._entry = _entry; $f._key = _key; $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._tmp = _tmp; $f._tmp$1 = _tmp$1; $f._tuple = _tuple; $f._tuple$1 = _tuple$1; $f._v = _v; $f.alreadythere = alreadythere; $f.err = err; $f.err$1 = err$1; $f.err$2 = err$2; $f.f = f; $f.flag = flag; $f.fv = fv; $f.hasValue = hasValue; $f.i = i; $f.m = m; $f.name = name; $f.numMinuses = numMinuses; $f.ok = ok; $f.s = s; $f.value = value; $f.x$1 = x$1; $f.x$2 = x$2; $f.$s = $s; $f.$r = $r; return $f; + }; + FlagSet.prototype.parseOne = function() { return this.$val.parseOne(); }; + FlagSet.ptr.prototype.Parse = function(arguments$1) { + var $ptr, _2, _r, _tuple, arguments$1, err, f, seen, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _2 = $f._2; _r = $f._r; _tuple = $f._tuple; arguments$1 = $f.arguments$1; err = $f.err; f = $f.f; seen = $f.seen; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = this; + f.parsed = true; + f.args = arguments$1; + /* while (true) { */ case 1: + _r = f.parseOne(); /* */ $s = 3; case 3: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + seen = _tuple[0]; + err = _tuple[1]; + if (seen) { + /* continue; */ $s = 1; continue; + } + if ($interfaceIsEqual(err, $ifaceNil)) { + /* break; */ $s = 2; continue; + } + _2 = f.errorHandling; + if (_2 === (0)) { + return err; + } else if (_2 === (1)) { + os.Exit(2); + } else if (_2 === (2)) { + $panic(err); + } + /* } */ $s = 1; continue; case 2: + return $ifaceNil; + /* */ } return; } if ($f === undefined) { $f = { $blk: FlagSet.ptr.prototype.Parse }; } $f.$ptr = $ptr; $f._2 = _2; $f._r = _r; $f._tuple = _tuple; $f.arguments$1 = arguments$1; $f.err = err; $f.f = f; $f.seen = seen; $f.$s = $s; $f.$r = $r; return $f; + }; + FlagSet.prototype.Parse = function(arguments$1) { return this.$val.Parse(arguments$1); }; + FlagSet.ptr.prototype.Parsed = function() { + var $ptr, f; + f = this; + return f.parsed; + }; + FlagSet.prototype.Parsed = function() { return this.$val.Parsed(); }; + NewFlagSet = function(name, errorHandling) { + var $ptr, errorHandling, f, name; + f = new FlagSet.ptr($throwNilPointerError, name, false, false, false, sliceType$2.nil, errorHandling, $ifaceNil); + return f; + }; + $pkg.NewFlagSet = NewFlagSet; + FlagSet.ptr.prototype.Init = function(name, errorHandling) { + var $ptr, errorHandling, f, name; + f = this; + f.name = name; + f.errorHandling = errorHandling; + }; + FlagSet.prototype.Init = function(name, errorHandling) { return this.$val.Init(name, errorHandling); }; + ptrType.methods = [{prop: "Set", name: "Set", pkg: "", typ: $funcType([$String], [$error], false)}, {prop: "Get", name: "Get", pkg: "", typ: $funcType([], [$emptyInterface], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}, {prop: "IsBoolFlag", name: "IsBoolFlag", pkg: "", typ: $funcType([], [$Bool], false)}]; + ptrType$1.methods = [{prop: "Set", name: "Set", pkg: "", typ: $funcType([$String], [$error], false)}, {prop: "Get", name: "Get", pkg: "", typ: $funcType([], [$emptyInterface], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}]; + ptrType$2.methods = [{prop: "Set", name: "Set", pkg: "", typ: $funcType([$String], [$error], false)}, {prop: "Get", name: "Get", pkg: "", typ: $funcType([], [$emptyInterface], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}]; + ptrType$3.methods = [{prop: "Set", name: "Set", pkg: "", typ: $funcType([$String], [$error], false)}, {prop: "Get", name: "Get", pkg: "", typ: $funcType([], [$emptyInterface], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}]; + ptrType$4.methods = [{prop: "Set", name: "Set", pkg: "", typ: $funcType([$String], [$error], false)}, {prop: "Get", name: "Get", pkg: "", typ: $funcType([], [$emptyInterface], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}]; + ptrType$5.methods = [{prop: "Set", name: "Set", pkg: "", typ: $funcType([$String], [$error], false)}, {prop: "Get", name: "Get", pkg: "", typ: $funcType([], [$emptyInterface], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}]; + ptrType$6.methods = [{prop: "Set", name: "Set", pkg: "", typ: $funcType([$String], [$error], false)}, {prop: "Get", name: "Get", pkg: "", typ: $funcType([], [$emptyInterface], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}]; + ptrType$7.methods = [{prop: "Set", name: "Set", pkg: "", typ: $funcType([$String], [$error], false)}, {prop: "Get", name: "Get", pkg: "", typ: $funcType([], [$emptyInterface], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}]; + ptrType$17.methods = [{prop: "out", name: "out", pkg: "flag", typ: $funcType([], [io.Writer], false)}, {prop: "SetOutput", name: "SetOutput", pkg: "", typ: $funcType([io.Writer], [], false)}, {prop: "VisitAll", name: "VisitAll", pkg: "", typ: $funcType([funcType], [], false)}, {prop: "Visit", name: "Visit", pkg: "", typ: $funcType([funcType], [], false)}, {prop: "Lookup", name: "Lookup", pkg: "", typ: $funcType([$String], [ptrType$9], false)}, {prop: "Set", name: "Set", pkg: "", typ: $funcType([$String, $String], [$error], false)}, {prop: "PrintDefaults", name: "PrintDefaults", pkg: "", typ: $funcType([], [], false)}, {prop: "NFlag", name: "NFlag", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Arg", name: "Arg", pkg: "", typ: $funcType([$Int], [$String], false)}, {prop: "NArg", name: "NArg", pkg: "", typ: $funcType([], [$Int], false)}, {prop: "Args", name: "Args", pkg: "", typ: $funcType([], [sliceType$2], false)}, {prop: "BoolVar", name: "BoolVar", pkg: "", typ: $funcType([ptrType$10, $String, $Bool, $String], [], false)}, {prop: "Bool", name: "Bool", pkg: "", typ: $funcType([$String, $Bool, $String], [ptrType$10], false)}, {prop: "IntVar", name: "IntVar", pkg: "", typ: $funcType([ptrType$11, $String, $Int, $String], [], false)}, {prop: "Int", name: "Int", pkg: "", typ: $funcType([$String, $Int, $String], [ptrType$11], false)}, {prop: "Int64Var", name: "Int64Var", pkg: "", typ: $funcType([ptrType$12, $String, $Int64, $String], [], false)}, {prop: "Int64", name: "Int64", pkg: "", typ: $funcType([$String, $Int64, $String], [ptrType$12], false)}, {prop: "UintVar", name: "UintVar", pkg: "", typ: $funcType([ptrType$13, $String, $Uint, $String], [], false)}, {prop: "Uint", name: "Uint", pkg: "", typ: $funcType([$String, $Uint, $String], [ptrType$13], false)}, {prop: "Uint64Var", name: "Uint64Var", pkg: "", typ: $funcType([ptrType$14, $String, $Uint64, $String], [], false)}, {prop: "Uint64", name: "Uint64", pkg: "", typ: $funcType([$String, $Uint64, $String], [ptrType$14], false)}, {prop: "StringVar", name: "StringVar", pkg: "", typ: $funcType([ptrType$15, $String, $String, $String], [], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([$String, $String, $String], [ptrType$15], false)}, {prop: "Float64Var", name: "Float64Var", pkg: "", typ: $funcType([ptrType$16, $String, $Float64, $String], [], false)}, {prop: "Float64", name: "Float64", pkg: "", typ: $funcType([$String, $Float64, $String], [ptrType$16], false)}, {prop: "DurationVar", name: "DurationVar", pkg: "", typ: $funcType([ptrType$8, $String, time.Duration, $String], [], false)}, {prop: "Duration", name: "Duration", pkg: "", typ: $funcType([$String, time.Duration, $String], [ptrType$8], false)}, {prop: "Var", name: "Var", pkg: "", typ: $funcType([Value, $String, $String], [], false)}, {prop: "failf", name: "failf", pkg: "flag", typ: $funcType([$String, sliceType], [$error], true)}, {prop: "usage", name: "usage", pkg: "flag", typ: $funcType([], [], false)}, {prop: "parseOne", name: "parseOne", pkg: "flag", typ: $funcType([], [$Bool, $error], false)}, {prop: "Parse", name: "Parse", pkg: "", typ: $funcType([sliceType$2], [$error], false)}, {prop: "Parsed", name: "Parsed", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Init", name: "Init", pkg: "", typ: $funcType([$String, ErrorHandling], [], false)}]; + boolFlag.init([{prop: "IsBoolFlag", name: "IsBoolFlag", pkg: "", typ: $funcType([], [$Bool], false)}, {prop: "Set", name: "Set", pkg: "", typ: $funcType([$String], [$error], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}]); + Value.init([{prop: "Set", name: "Set", pkg: "", typ: $funcType([$String], [$error], false)}, {prop: "String", name: "String", pkg: "", typ: $funcType([], [$String], false)}]); + FlagSet.init([{prop: "Usage", name: "Usage", pkg: "", typ: funcType$1, tag: ""}, {prop: "name", name: "name", pkg: "flag", typ: $String, tag: ""}, {prop: "parsed", name: "parsed", pkg: "flag", typ: $Bool, tag: ""}, {prop: "actual", name: "actual", pkg: "flag", typ: mapType, tag: ""}, {prop: "formal", name: "formal", pkg: "flag", typ: mapType, tag: ""}, {prop: "args", name: "args", pkg: "flag", typ: sliceType$2, tag: ""}, {prop: "errorHandling", name: "errorHandling", pkg: "flag", typ: ErrorHandling, tag: ""}, {prop: "output", name: "output", pkg: "flag", typ: io.Writer, tag: ""}]); + Flag.init([{prop: "Name", name: "Name", pkg: "", typ: $String, tag: ""}, {prop: "Usage", name: "Usage", pkg: "", typ: $String, tag: ""}, {prop: "Value", name: "Value", pkg: "", typ: Value, tag: ""}, {prop: "DefValue", name: "DefValue", pkg: "", 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 = 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 = os.$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 = time.$init(); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $pkg.ErrHelp = errors.New("flag: help requested"); + $pkg.CommandLine = NewFlagSet((x = os.Args, (0 >= x.$length ? $throwRuntimeError("index out of range") : x.$array[x.$offset + 0])), 1); + $pkg.Usage = (function $b() { + var $ptr, _r, x$1, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; x$1 = $f.x$1; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r = fmt.Fprintf(os.Stderr, "Usage of %s:\n", new sliceType([new $String((x$1 = os.Args, (0 >= x$1.$length ? $throwRuntimeError("index out of range") : x$1.$array[x$1.$offset + 0])))])); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _r; + $r = PrintDefaults(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f._r = _r; $f.x$1 = x$1; $f.$s = $s; $f.$r = $r; return $f; + }); + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["runtime/debug"] = (function() { + var $pkg = {}, $init, os, runtime, sort, time; + os = $packages["os"]; + runtime = $packages["runtime"]; + sort = $packages["sort"]; + time = $packages["time"]; + $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 = os.$init(); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = runtime.$init(); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = sort.$init(); /* */ $s = 3; case 3: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = time.$init(); /* */ $s = 4; case 4: 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["runtime/pprof"] = (function() { + var $pkg = {}, $init, io, sync; + io = $packages["io"]; + sync = $packages["sync"]; + $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; } + $r = sync.$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["runtime/trace"] = (function() { + var $pkg = {}, $init, io, runtime; + io = $packages["io"]; + runtime = $packages["runtime"]; + $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; } + $r = runtime.$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["testing"] = (function() { + var $pkg = {}, $init, bytes, flag, fmt, nosync, io, os, runtime, debug, pprof, trace, strconv, strings, atomic, time, matchBenchmarks, benchTime, benchmarkMemory, short$1, outputDir, chatty, count, coverProfile, match, memProfile, memProfileRate, cpuProfile, blockProfile, blockProfileRate, traceFile, timeout, cpuListStr, parallel, _r, _r$1, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _r$8, _r$9, _r$10, _r$11, _r$12, _r$13, _r$14, _r$15, _r$16, _r$17; + bytes = $packages["bytes"]; + flag = $packages["flag"]; + fmt = $packages["fmt"]; + nosync = $packages["github.com/gopherjs/gopherjs/nosync"]; + io = $packages["io"]; + os = $packages["os"]; + runtime = $packages["runtime"]; + debug = $packages["runtime/debug"]; + pprof = $packages["runtime/pprof"]; + trace = $packages["runtime/trace"]; + strconv = $packages["strconv"]; + strings = $packages["strings"]; + atomic = $packages["sync/atomic"]; + time = $packages["time"]; + $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 = flag.$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 = nosync.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = io.$init(); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = os.$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 = debug.$init(); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = pprof.$init(); /* */ $s = 9; case 9: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = trace.$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 = atomic.$init(); /* */ $s = 13; case 13: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = time.$init(); /* */ $s = 14; case 14: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + _r = flag.String("test.bench", "", "regular expression to select benchmarks to run"); /* */ $s = 15; case 15: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + matchBenchmarks = _r; + _r$1 = flag.Duration("test.benchtime", new time.Duration(0, 1000000000), "approximate run time for each benchmark"); /* */ $s = 16; case 16: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + benchTime = _r$1; + _r$2 = flag.Bool("test.benchmem", false, "print memory allocations for benchmarks"); /* */ $s = 17; case 17: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + benchmarkMemory = _r$2; + _r$3 = flag.Bool("test.short", false, "run smaller test suite to save time"); /* */ $s = 18; case 18: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + short$1 = _r$3; + _r$4 = flag.String("test.outputdir", "", "directory in which to write profiles"); /* */ $s = 19; case 19: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + outputDir = _r$4; + _r$5 = flag.Bool("test.v", false, "verbose: print additional output"); /* */ $s = 20; case 20: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + chatty = _r$5; + _r$6 = flag.Uint("test.count", 1, "run tests and benchmarks `n` times"); /* */ $s = 21; case 21: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + count = _r$6; + _r$7 = flag.String("test.coverprofile", "", "write a coverage profile to the named file after execution"); /* */ $s = 22; case 22: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } + coverProfile = _r$7; + _r$8 = flag.String("test.run", "", "regular expression to select tests and examples to run"); /* */ $s = 23; case 23: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; } + match = _r$8; + _r$9 = flag.String("test.memprofile", "", "write a memory profile to the named file after execution"); /* */ $s = 24; case 24: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; } + memProfile = _r$9; + _r$10 = flag.Int("test.memprofilerate", 0, "if >=0, sets runtime.MemProfileRate"); /* */ $s = 25; case 25: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; } + memProfileRate = _r$10; + _r$11 = flag.String("test.cpuprofile", "", "write a cpu profile to the named file during execution"); /* */ $s = 26; case 26: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; } + cpuProfile = _r$11; + _r$12 = flag.String("test.blockprofile", "", "write a goroutine blocking profile to the named file after execution"); /* */ $s = 27; case 27: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; } + blockProfile = _r$12; + _r$13 = flag.Int("test.blockprofilerate", 1, "if >= 0, calls runtime.SetBlockProfileRate()"); /* */ $s = 28; case 28: if($c) { $c = false; _r$13 = _r$13.$blk(); } if (_r$13 && _r$13.$blk !== undefined) { break s; } + blockProfileRate = _r$13; + _r$14 = flag.String("test.trace", "", "write an execution trace to the named file after execution"); /* */ $s = 29; case 29: if($c) { $c = false; _r$14 = _r$14.$blk(); } if (_r$14 && _r$14.$blk !== undefined) { break s; } + traceFile = _r$14; + _r$15 = flag.Duration("test.timeout", new time.Duration(0, 0), "if positive, sets an aggregate time limit for all tests"); /* */ $s = 30; case 30: if($c) { $c = false; _r$15 = _r$15.$blk(); } if (_r$15 && _r$15.$blk !== undefined) { break s; } + timeout = _r$15; + _r$16 = flag.String("test.cpu", "", "comma-separated list of number of CPUs to use for each test"); /* */ $s = 31; case 31: if($c) { $c = false; _r$16 = _r$16.$blk(); } if (_r$16 && _r$16.$blk !== undefined) { break s; } + cpuListStr = _r$16; + _r$17 = flag.Int("test.parallel", runtime.GOMAXPROCS(0), "maximum test parallelism"); /* */ $s = 32; case 32: if($c) { $c = false; _r$17 = _r$17.$blk(); } if (_r$17 && _r$17.$blk !== undefined) { break s; } + parallel = _r$17; + /* */ } 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, runtime, sort, strconv, strings, testing, unicode, utf16, utf8, Number, Marshaler, UnsupportedTypeError, UnsupportedValueError, MarshalerError, encodeState, encoderFunc, floatEncoder, structEncoder, mapEncoder, sliceEncoder, arrayEncoder, ptrEncoder, condAddrEncoder, stringValues, field, byName, byIndex, SyntaxError, scanner, tagOptions, sliceType, mapType, structType, sliceType$1, mapType$1, structType$1, sliceType$2, ptrType, ptrType$1, sliceType$3, ptrType$2, arrayType, arrayType$1, ptrType$4, sliceType$4, ptrType$8, ptrType$13, ptrType$14, ptrType$16, ptrType$17, ptrType$18, ptrType$19, ptrType$20, ptrType$21, ptrType$22, funcType, ptrType$23, funcType$1, errPhase, numberType, hex, encoderCache, marshalerType, textMarshalerType, float32Encoder, float64Encoder, fieldCache, _r, _r$1, isValidNumber, Marshal, isEmptyValue, valueEncoder, typeEncoder, newTypeEncoder, invalidValueEncoder, marshalerEncoder, addrMarshalerEncoder, textMarshalerEncoder, addrTextMarshalerEncoder, boolEncoder, intEncoder, uintEncoder, stringEncoder, interfaceEncoder, unsupportedTypeEncoder, newStructEncoder, newMapEncoder, encodeByteSlice, newSliceEncoder, newArrayEncoder, newPtrEncoder, newCondAddrEncoder, isValidTag, fieldByIndex, typeByIndex, fillField, 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"]; + runtime = $packages["runtime"]; + sort = $packages["sort"]; + strconv = $packages["strconv"]; + strings = $packages["strings"]; + testing = $packages["testing"]; + unicode = $packages["unicode"]; + utf16 = $packages["unicode/utf16"]; + utf8 = $packages["unicode/utf8"]; + Number = $pkg.Number = $newType(8, $kindString, "json.Number", "Number", "encoding/json", null); + Marshaler = $pkg.Marshaler = $newType(8, $kindInterface, "json.Marshaler", "Marshaler", "encoding/json", null); + UnsupportedTypeError = $pkg.UnsupportedTypeError = $newType(0, $kindStruct, "json.UnsupportedTypeError", "UnsupportedTypeError", "encoding/json", function(Type_) { + this.$val = this; + if (arguments.length === 0) { + this.Type = $ifaceNil; + return; + } + this.Type = Type_; + }); + UnsupportedValueError = $pkg.UnsupportedValueError = $newType(0, $kindStruct, "json.UnsupportedValueError", "UnsupportedValueError", "encoding/json", function(Value_, Str_) { + this.$val = this; + if (arguments.length === 0) { + this.Value = new reflect.Value.ptr(ptrType$2.nil, 0, 0); + this.Str = ""; + return; + } + this.Value = Value_; + this.Str = Str_; + }); + MarshalerError = $pkg.MarshalerError = $newType(0, $kindStruct, "json.MarshalerError", "MarshalerError", "encoding/json", 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", "encodeState", "encoding/json", function(Buffer_, scratch_) { + this.$val = this; + if (arguments.length === 0) { + this.Buffer = new bytes.Buffer.ptr(sliceType$2.nil, 0, arrayType.zero(), arrayType$1.zero(), 0); + this.scratch = arrayType$1.zero(); + return; + } + this.Buffer = Buffer_; + this.scratch = scratch_; + }); + encoderFunc = $pkg.encoderFunc = $newType(4, $kindFunc, "json.encoderFunc", "encoderFunc", "encoding/json", null); + floatEncoder = $pkg.floatEncoder = $newType(4, $kindInt, "json.floatEncoder", "floatEncoder", "encoding/json", null); + structEncoder = $pkg.structEncoder = $newType(0, $kindStruct, "json.structEncoder", "structEncoder", "encoding/json", function(fields_, fieldEncs_) { + this.$val = this; + if (arguments.length === 0) { + this.fields = sliceType$1.nil; + this.fieldEncs = sliceType$4.nil; + return; + } + this.fields = fields_; + this.fieldEncs = fieldEncs_; + }); + mapEncoder = $pkg.mapEncoder = $newType(0, $kindStruct, "json.mapEncoder", "mapEncoder", "encoding/json", function(elemEnc_) { + this.$val = this; + if (arguments.length === 0) { + this.elemEnc = $throwNilPointerError; + return; + } + this.elemEnc = elemEnc_; + }); + sliceEncoder = $pkg.sliceEncoder = $newType(0, $kindStruct, "json.sliceEncoder", "sliceEncoder", "encoding/json", function(arrayEnc_) { + this.$val = this; + if (arguments.length === 0) { + this.arrayEnc = $throwNilPointerError; + return; + } + this.arrayEnc = arrayEnc_; + }); + arrayEncoder = $pkg.arrayEncoder = $newType(0, $kindStruct, "json.arrayEncoder", "arrayEncoder", "encoding/json", function(elemEnc_) { + this.$val = this; + if (arguments.length === 0) { + this.elemEnc = $throwNilPointerError; + return; + } + this.elemEnc = elemEnc_; + }); + ptrEncoder = $pkg.ptrEncoder = $newType(0, $kindStruct, "json.ptrEncoder", "ptrEncoder", "encoding/json", function(elemEnc_) { + this.$val = this; + if (arguments.length === 0) { + this.elemEnc = $throwNilPointerError; + return; + } + this.elemEnc = elemEnc_; + }); + condAddrEncoder = $pkg.condAddrEncoder = $newType(0, $kindStruct, "json.condAddrEncoder", "condAddrEncoder", "encoding/json", function(canAddrEnc_, elseEnc_) { + this.$val = this; + if (arguments.length === 0) { + this.canAddrEnc = $throwNilPointerError; + this.elseEnc = $throwNilPointerError; + return; + } + this.canAddrEnc = canAddrEnc_; + this.elseEnc = elseEnc_; + }); + stringValues = $pkg.stringValues = $newType(12, $kindSlice, "json.stringValues", "stringValues", "encoding/json", null); + field = $pkg.field = $newType(0, $kindStruct, "json.field", "field", "encoding/json", function(name_, nameBytes_, equalFold_, tag_, index_, typ_, omitEmpty_, quoted_) { + this.$val = this; + if (arguments.length === 0) { + this.name = ""; + this.nameBytes = sliceType$2.nil; + this.equalFold = $throwNilPointerError; + this.tag = false; + this.index = sliceType$3.nil; + this.typ = $ifaceNil; + this.omitEmpty = false; + this.quoted = false; + return; + } + this.name = name_; + this.nameBytes = nameBytes_; + this.equalFold = equalFold_; + this.tag = tag_; + this.index = index_; + this.typ = typ_; + this.omitEmpty = omitEmpty_; + this.quoted = quoted_; + }); + byName = $pkg.byName = $newType(12, $kindSlice, "json.byName", "byName", "encoding/json", null); + byIndex = $pkg.byIndex = $newType(12, $kindSlice, "json.byIndex", "byIndex", "encoding/json", null); + SyntaxError = $pkg.SyntaxError = $newType(0, $kindStruct, "json.SyntaxError", "SyntaxError", "encoding/json", 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", "scanner", "encoding/json", function(step_, endTop_, parseState_, err_, redo_, redoCode_, redoState_, bytes_) { + this.$val = this; + if (arguments.length === 0) { + this.step = $throwNilPointerError; + this.endTop = false; + this.parseState = sliceType$3.nil; + this.err = $ifaceNil; + this.redo = false; + this.redoCode = 0; + this.redoState = $throwNilPointerError; + this.bytes = new $Int64(0, 0); + return; + } + this.step = step_; + this.endTop = endTop_; + this.parseState = parseState_; + this.err = err_; + this.redo = redo_; + this.redoCode = redoCode_; + this.redoState = redoState_; + this.bytes = bytes_; + }); + tagOptions = $pkg.tagOptions = $newType(8, $kindString, "json.tagOptions", "tagOptions", "encoding/json", null); + sliceType = $sliceType($emptyInterface); + mapType = $mapType(reflect.Type, encoderFunc); + structType = $structType([{prop: "RWMutex", name: "", pkg: "", typ: nosync.RWMutex, tag: ""}, {prop: "m", name: "m", pkg: "encoding/json", typ: mapType, tag: ""}]); + sliceType$1 = $sliceType(field); + mapType$1 = $mapType(reflect.Type, sliceType$1); + structType$1 = $structType([{prop: "RWMutex", name: "", pkg: "", typ: nosync.RWMutex, tag: ""}, {prop: "m", name: "m", pkg: "encoding/json", typ: mapType$1, tag: ""}]); + sliceType$2 = $sliceType($Uint8); + ptrType = $ptrType(Marshaler); + ptrType$1 = $ptrType(encoding.TextMarshaler); + sliceType$3 = $sliceType($Int); + ptrType$2 = $ptrType(reflect.rtype); + arrayType = $arrayType($Uint8, 4); + arrayType$1 = $arrayType($Uint8, 64); + ptrType$4 = $ptrType(encodeState); + sliceType$4 = $sliceType(encoderFunc); + ptrType$8 = $ptrType(SyntaxError); + ptrType$13 = $ptrType(UnsupportedTypeError); + ptrType$14 = $ptrType(UnsupportedValueError); + ptrType$16 = $ptrType(MarshalerError); + ptrType$17 = $ptrType(structEncoder); + ptrType$18 = $ptrType(mapEncoder); + ptrType$19 = $ptrType(sliceEncoder); + ptrType$20 = $ptrType(arrayEncoder); + ptrType$21 = $ptrType(ptrEncoder); + ptrType$22 = $ptrType(condAddrEncoder); + funcType = $funcType([sliceType$2, sliceType$2], [$Bool], false); + ptrType$23 = $ptrType(scanner); + funcType$1 = $funcType([ptrType$23, $Uint8], [$Int], false); + Number.prototype.String = function() { + var $ptr, n; + n = this.$val; + return n; + }; + $ptrType(Number).prototype.String = function() { return new Number(this.$get()).String(); }; + Number.prototype.Float64 = function() { + var $ptr, 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 $ptr, 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 $ptr, s; + if (s === "") { + return false; + } + if (s.charCodeAt(0) === 45) { + s = s.substring(1); + if (s === "") { + return false; + } + } + if ((s.charCodeAt(0) === 48)) { + s = s.substring(1); + } else if (49 <= s.charCodeAt(0) && s.charCodeAt(0) <= 57) { + s = s.substring(1); + while (true) { + if (!(s.length > 0 && 48 <= s.charCodeAt(0) && s.charCodeAt(0) <= 57)) { break; } + s = s.substring(1); + } + } else { + return false; + } + if (s.length >= 2 && (s.charCodeAt(0) === 46) && 48 <= s.charCodeAt(1) && s.charCodeAt(1) <= 57) { + s = s.substring(2); + while (true) { + if (!(s.length > 0 && 48 <= s.charCodeAt(0) && s.charCodeAt(0) <= 57)) { break; } + s = s.substring(1); + } + } + if (s.length >= 2 && ((s.charCodeAt(0) === 101) || (s.charCodeAt(0) === 69))) { + s = s.substring(1); + if ((s.charCodeAt(0) === 43) || (s.charCodeAt(0) === 45)) { + s = s.substring(1); + if (s === "") { + return false; + } + } + while (true) { + if (!(s.length > 0 && 48 <= s.charCodeAt(0) && s.charCodeAt(0) <= 57)) { break; } + s = s.substring(1); + } + } + return s === ""; + }; + Marshal = function(v) { + var $ptr, _r$2, e, err, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; e = $f.e; err = $f.err; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + e = new encodeState.ptr(new bytes.Buffer.ptr(sliceType$2.nil, 0, arrayType.zero(), arrayType$1.zero(), 0), arrayType$1.zero()); + _r$2 = e.marshal(v); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + err = _r$2; + if (!($interfaceIsEqual(err, $ifaceNil))) { + return [sliceType$2.nil, err]; + } + return [e.Buffer.Bytes(), $ifaceNil]; + /* */ } return; } if ($f === undefined) { $f = { $blk: Marshal }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f.e = e; $f.err = err; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.Marshal = Marshal; + UnsupportedTypeError.ptr.prototype.Error = function() { + var $ptr, _r$2, e, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; e = $f.e; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + e = this; + _r$2 = e.Type.String(); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + /* */ $s = 2; case 2: + return "json: unsupported type: " + _r$2; + /* */ } return; } if ($f === undefined) { $f = { $blk: UnsupportedTypeError.ptr.prototype.Error }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $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 $ptr, e; + e = this; + return "json: unsupported value: " + e.Str; + }; + UnsupportedValueError.prototype.Error = function() { return this.$val.Error(); }; + MarshalerError.ptr.prototype.Error = function() { + var $ptr, _r$2, _r$3, e, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; e = $f.e; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + e = this; + _r$2 = e.Type.String(); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _r$3 = e.Err.Error(); /* */ $s = 2; case 2: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + /* */ $s = 3; case 3: + return "json: error calling MarshalJSON for type " + _r$2 + ": " + _r$3; + /* */ } return; } if ($f === undefined) { $f = { $blk: MarshalerError.ptr.prototype.Error }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $f.e = e; $f.$s = $s; $f.$r = $r; return $f; + }; + MarshalerError.prototype.Error = function() { return this.$val.Error(); }; + encodeState.ptr.prototype.marshal = function(v) { + var $ptr, _r$2, e, err, v, $s, $deferred, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; e = $f.e; err = $f.err; 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 $ptr, _tuple, _tuple$1, ok, ok$1, r, s; + r = $recover(); + if (!($interfaceIsEqual(r, $ifaceNil))) { + _tuple = $assertType(r, runtime.Error, true); + ok = _tuple[1]; + if (ok) { + $panic(r); + } + _tuple$1 = $assertType(r, $String, true); + s = _tuple$1[0]; + ok$1 = _tuple$1[1]; + if (ok$1) { + $panic(new $String(s)); + } + err[0] = $assertType(r, $error); + } + }; })(err), []]); + _r$2 = reflect.ValueOf(v); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + $r = e.reflectValue(_r$2); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + err[0] = $ifaceNil; + 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.$ptr = $ptr; $f._r$2 = _r$2; $f.e = e; $f.err = err; $f.v = v; $f.$s = $s; $f.$deferred = $deferred; $f.$r = $r; return $f; } } + }; + encodeState.prototype.marshal = function(v) { return this.$val.marshal(v); }; + encodeState.ptr.prototype.error = function(err) { + var $ptr, e, err; + e = this; + $panic(err); + }; + encodeState.prototype.error = function(err) { return this.$val.error(err); }; + isEmptyValue = function(v) { + var $ptr, _1, v, x, x$1; + v = v; + _1 = v.Kind(); + if ((_1 === (17)) || (_1 === (21)) || (_1 === (23)) || (_1 === (24))) { + return v.Len() === 0; + } else if (_1 === (1)) { + return !v.Bool(); + } else if ((_1 === (2)) || (_1 === (3)) || (_1 === (4)) || (_1 === (5)) || (_1 === (6))) { + return (x = v.Int(), (x.$high === 0 && x.$low === 0)); + } else if ((_1 === (7)) || (_1 === (8)) || (_1 === (9)) || (_1 === (10)) || (_1 === (11)) || (_1 === (12))) { + return (x$1 = v.Uint(), (x$1.$high === 0 && x$1.$low === 0)); + } else if ((_1 === (13)) || (_1 === (14))) { + return v.Float() === 0; + } else if ((_1 === (20)) || (_1 === (22))) { + return v.IsNil(); + } + return false; + }; + encodeState.ptr.prototype.reflectValue = function(v) { + var $ptr, _r$2, e, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; e = $f.e; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = v; + e = this; + _r$2 = valueEncoder(v); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + $r = _r$2(e, v, false); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: encodeState.ptr.prototype.reflectValue }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f.e = e; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + encodeState.prototype.reflectValue = function(v) { return this.$val.reflectValue(v); }; + valueEncoder = function(v) { + var $ptr, _r$2, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = v; + if (!v.IsValid()) { + return invalidValueEncoder; + } + _r$2 = typeEncoder(v.Type()); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + /* */ $s = 2; case 2: + return _r$2; + /* */ } return; } if ($f === undefined) { $f = { $blk: valueEncoder }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + typeEncoder = function(t) { + var $ptr, _entry, _key, _key$1, _r$2, f, t, wg, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _key = $f._key; _key$1 = $f._key$1; _r$2 = $f._r$2; f = $f.f; t = $f.t; wg = $f.wg; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + f = [f]; + wg = [wg]; + encoderCache.RWMutex.RLock(); + f[0] = (_entry = encoderCache.m[reflect.Type.keyFor(t)], _entry !== undefined ? _entry.v : $throwNilPointerError); + encoderCache.RWMutex.RUnlock(); + if (!(f[0] === $throwNilPointerError)) { + return f[0]; + } + encoderCache.RWMutex.Lock(); + if (encoderCache.m === false) { + encoderCache.m = {}; + } + wg[0] = new nosync.WaitGroup.ptr(0); + wg[0].Add(1); + _key = t; (encoderCache.m || $throwRuntimeError("assignment to entry in nil map"))[reflect.Type.keyFor(_key)] = { k: _key, v: (function(f, wg) { return function $b(e, v, quoted) { + var $ptr, e, quoted, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; e = $f.e; quoted = $f.quoted; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = v; + wg[0].Wait(); + $r = f[0](e, v, quoted); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: $b }; } $f.$ptr = $ptr; $f.e = e; $f.quoted = quoted; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; })(f, wg) }; + encoderCache.RWMutex.Unlock(); + _r$2 = newTypeEncoder(t, true); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + f[0] = _r$2; + wg[0].Done(); + encoderCache.RWMutex.Lock(); + _key$1 = t; (encoderCache.m || $throwRuntimeError("assignment to entry in nil map"))[reflect.Type.keyFor(_key$1)] = { k: _key$1, v: f[0] }; + encoderCache.RWMutex.Unlock(); + return f[0]; + /* */ } return; } if ($f === undefined) { $f = { $blk: typeEncoder }; } $f.$ptr = $ptr; $f._entry = _entry; $f._key = _key; $f._key$1 = _key$1; $f._r$2 = _r$2; $f.f = f; $f.t = t; $f.wg = wg; $f.$s = $s; $f.$r = $r; return $f; + }; + newTypeEncoder = function(t, allowAddr) { + var $ptr, _2, _arg, _arg$1, _arg$2, _arg$3, _r$10, _r$11, _r$12, _r$13, _r$14, _r$15, _r$16, _r$17, _r$2, _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; $ptr = $f.$ptr; _2 = $f._2; _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$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; allowAddr = $f.allowAddr; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r$2 = t.Implements(marshalerType); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + /* */ if (_r$2) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (_r$2) { */ case 1: + return marshalerEncoder; + /* } */ case 2: + _r$3 = t.Kind(); /* */ $s = 6; case 6: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + /* */ if (!((_r$3 === 22)) && allowAddr) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (!((_r$3 === 22)) && allowAddr) { */ case 4: + _r$4 = reflect.PtrTo(t).Implements(marshalerType); /* */ $s = 9; case 9: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + /* */ if (_r$4) { $s = 7; continue; } + /* */ $s = 8; continue; + /* if (_r$4) { */ case 7: + _arg = addrMarshalerEncoder; + _r$5 = newTypeEncoder(t, false); /* */ $s = 10; case 10: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + _arg$1 = _r$5; + _r$6 = newCondAddrEncoder(_arg, _arg$1); /* */ $s = 11; case 11: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + /* */ $s = 12; case 12: + return _r$6; + /* } */ case 8: + /* } */ case 5: + _r$7 = t.Implements(textMarshalerType); /* */ $s = 15; case 15: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } + /* */ if (_r$7) { $s = 13; continue; } + /* */ $s = 14; continue; + /* if (_r$7) { */ case 13: + return textMarshalerEncoder; + /* } */ case 14: + _r$8 = t.Kind(); /* */ $s = 18; case 18: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; } + /* */ if (!((_r$8 === 22)) && allowAddr) { $s = 16; continue; } + /* */ $s = 17; continue; + /* if (!((_r$8 === 22)) && allowAddr) { */ case 16: + _r$9 = reflect.PtrTo(t).Implements(textMarshalerType); /* */ $s = 21; case 21: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; } + /* */ if (_r$9) { $s = 19; continue; } + /* */ $s = 20; continue; + /* if (_r$9) { */ case 19: + _arg$2 = addrTextMarshalerEncoder; + _r$10 = newTypeEncoder(t, false); /* */ $s = 22; case 22: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; } + _arg$3 = _r$10; + _r$11 = newCondAddrEncoder(_arg$2, _arg$3); /* */ $s = 23; case 23: if($c) { $c = false; _r$11 = _r$11.$blk(); } if (_r$11 && _r$11.$blk !== undefined) { break s; } + /* */ $s = 24; case 24: + return _r$11; + /* } */ case 20: + /* } */ case 17: + _r$12 = t.Kind(); /* */ $s = 26; case 26: if($c) { $c = false; _r$12 = _r$12.$blk(); } if (_r$12 && _r$12.$blk !== undefined) { break s; } + _2 = _r$12; + /* */ if (_2 === (1)) { $s = 27; continue; } + /* */ if ((_2 === (2)) || (_2 === (3)) || (_2 === (4)) || (_2 === (5)) || (_2 === (6))) { $s = 28; continue; } + /* */ if ((_2 === (7)) || (_2 === (8)) || (_2 === (9)) || (_2 === (10)) || (_2 === (11)) || (_2 === (12))) { $s = 29; continue; } + /* */ if (_2 === (13)) { $s = 30; continue; } + /* */ if (_2 === (14)) { $s = 31; continue; } + /* */ if (_2 === (24)) { $s = 32; continue; } + /* */ if (_2 === (20)) { $s = 33; continue; } + /* */ if (_2 === (25)) { $s = 34; continue; } + /* */ if (_2 === (21)) { $s = 35; continue; } + /* */ if (_2 === (23)) { $s = 36; continue; } + /* */ if (_2 === (17)) { $s = 37; continue; } + /* */ if (_2 === (22)) { $s = 38; continue; } + /* */ $s = 39; continue; + /* if (_2 === (1)) { */ case 27: + return boolEncoder; + /* } else if ((_2 === (2)) || (_2 === (3)) || (_2 === (4)) || (_2 === (5)) || (_2 === (6))) { */ case 28: + return intEncoder; + /* } else if ((_2 === (7)) || (_2 === (8)) || (_2 === (9)) || (_2 === (10)) || (_2 === (11)) || (_2 === (12))) { */ case 29: + return uintEncoder; + /* } else if (_2 === (13)) { */ case 30: + return float32Encoder; + /* } else if (_2 === (14)) { */ case 31: + return float64Encoder; + /* } else if (_2 === (24)) { */ case 32: + return stringEncoder; + /* } else if (_2 === (20)) { */ case 33: + return interfaceEncoder; + /* } else if (_2 === (25)) { */ case 34: + _r$13 = newStructEncoder(t); /* */ $s = 41; case 41: if($c) { $c = false; _r$13 = _r$13.$blk(); } if (_r$13 && _r$13.$blk !== undefined) { break s; } + /* */ $s = 42; case 42: + return _r$13; + /* } else if (_2 === (21)) { */ case 35: + _r$14 = newMapEncoder(t); /* */ $s = 43; case 43: if($c) { $c = false; _r$14 = _r$14.$blk(); } if (_r$14 && _r$14.$blk !== undefined) { break s; } + /* */ $s = 44; case 44: + return _r$14; + /* } else if (_2 === (23)) { */ case 36: + _r$15 = newSliceEncoder(t); /* */ $s = 45; case 45: if($c) { $c = false; _r$15 = _r$15.$blk(); } if (_r$15 && _r$15.$blk !== undefined) { break s; } + /* */ $s = 46; case 46: + return _r$15; + /* } else if (_2 === (17)) { */ case 37: + _r$16 = newArrayEncoder(t); /* */ $s = 47; case 47: if($c) { $c = false; _r$16 = _r$16.$blk(); } if (_r$16 && _r$16.$blk !== undefined) { break s; } + /* */ $s = 48; case 48: + return _r$16; + /* } else if (_2 === (22)) { */ case 38: + _r$17 = newPtrEncoder(t); /* */ $s = 49; case 49: if($c) { $c = false; _r$17 = _r$17.$blk(); } if (_r$17 && _r$17.$blk !== undefined) { break s; } + /* */ $s = 50; case 50: + return _r$17; + /* } else { */ case 39: + return unsupportedTypeEncoder; + /* } */ case 40: + case 25: + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: newTypeEncoder }; } $f.$ptr = $ptr; $f._2 = _2; $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$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.allowAddr = allowAddr; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + invalidValueEncoder = function(e, v, quoted) { + var $ptr, e, quoted, v; + v = v; + e.Buffer.WriteString("null"); + }; + marshalerEncoder = function(e, v, quoted) { + var $ptr, _r$2, _r$3, _r$4, _tuple, b, e, err, m, quoted, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _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; quoted = $f.quoted; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = v; + if ((v.Kind() === 22) && v.IsNil()) { + e.Buffer.WriteString("null"); + return; + } + _r$2 = v.Interface(); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + m = $assertType(_r$2, Marshaler); + _r$3 = m.MarshalJSON(); /* */ $s = 2; case 2: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _tuple = _r$3; + b = _tuple[0]; + err = _tuple[1]; + /* */ if ($interfaceIsEqual(err, $ifaceNil)) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if ($interfaceIsEqual(err, $ifaceNil)) { */ case 3: + _r$4 = compact(e.Buffer, b, true); /* */ $s = 5; case 5: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + err = _r$4; + /* } */ case 4: + if (!($interfaceIsEqual(err, $ifaceNil))) { + e.error(new MarshalerError.ptr(v.Type(), err)); + } + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: marshalerEncoder }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $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.quoted = quoted; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + addrMarshalerEncoder = function(e, v, quoted) { + var $ptr, _r$2, _r$3, _r$4, _tuple, b, e, err, m, quoted, v, va, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _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; quoted = $f.quoted; v = $f.v; va = $f.va; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = v; + va = v.Addr(); + if (va.IsNil()) { + e.Buffer.WriteString("null"); + return; + } + _r$2 = va.Interface(); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + m = $assertType(_r$2, Marshaler); + _r$3 = m.MarshalJSON(); /* */ $s = 2; case 2: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _tuple = _r$3; + b = _tuple[0]; + err = _tuple[1]; + /* */ if ($interfaceIsEqual(err, $ifaceNil)) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if ($interfaceIsEqual(err, $ifaceNil)) { */ case 3: + _r$4 = compact(e.Buffer, b, true); /* */ $s = 5; case 5: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + err = _r$4; + /* } */ case 4: + if (!($interfaceIsEqual(err, $ifaceNil))) { + e.error(new MarshalerError.ptr(v.Type(), err)); + } + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: addrMarshalerEncoder }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $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.quoted = quoted; $f.v = v; $f.va = va; $f.$s = $s; $f.$r = $r; return $f; + }; + textMarshalerEncoder = function(e, v, quoted) { + var $ptr, _r$2, _r$3, _tuple, b, e, err, m, quoted, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; _tuple = $f._tuple; b = $f.b; e = $f.e; err = $f.err; m = $f.m; quoted = $f.quoted; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = v; + if ((v.Kind() === 22) && v.IsNil()) { + e.Buffer.WriteString("null"); + return; + } + _r$2 = v.Interface(); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + m = $assertType(_r$2, encoding.TextMarshaler); + _r$3 = m.MarshalText(); /* */ $s = 2; case 2: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _tuple = _r$3; + b = _tuple[0]; + err = _tuple[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + e.error(new MarshalerError.ptr(v.Type(), err)); + } + e.stringBytes(b); + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: textMarshalerEncoder }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._tuple = _tuple; $f.b = b; $f.e = e; $f.err = err; $f.m = m; $f.quoted = quoted; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + addrTextMarshalerEncoder = function(e, v, quoted) { + var $ptr, _r$2, _r$3, _tuple, b, e, err, m, quoted, v, va, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; _tuple = $f._tuple; b = $f.b; e = $f.e; err = $f.err; m = $f.m; quoted = $f.quoted; v = $f.v; va = $f.va; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = v; + va = v.Addr(); + if (va.IsNil()) { + e.Buffer.WriteString("null"); + return; + } + _r$2 = va.Interface(); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + m = $assertType(_r$2, encoding.TextMarshaler); + _r$3 = m.MarshalText(); /* */ $s = 2; case 2: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _tuple = _r$3; + b = _tuple[0]; + err = _tuple[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + e.error(new MarshalerError.ptr(v.Type(), err)); + } + e.stringBytes(b); + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: addrTextMarshalerEncoder }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._tuple = _tuple; $f.b = b; $f.e = e; $f.err = err; $f.m = m; $f.quoted = quoted; $f.v = v; $f.va = va; $f.$s = $s; $f.$r = $r; return $f; + }; + boolEncoder = function(e, v, quoted) { + var $ptr, e, quoted, v; + v = v; + if (quoted) { + e.Buffer.WriteByte(34); + } + if (v.Bool()) { + e.Buffer.WriteString("true"); + } else { + e.Buffer.WriteString("false"); + } + if (quoted) { + e.Buffer.WriteByte(34); + } + }; + intEncoder = function(e, v, quoted) { + var $ptr, b, e, quoted, v; + v = v; + b = strconv.AppendInt($subslice(new sliceType$2(e.scratch), 0, 0), v.Int(), 10); + if (quoted) { + e.Buffer.WriteByte(34); + } + e.Buffer.Write(b); + if (quoted) { + e.Buffer.WriteByte(34); + } + }; + uintEncoder = function(e, v, quoted) { + var $ptr, b, e, quoted, v; + v = v; + b = strconv.AppendUint($subslice(new sliceType$2(e.scratch), 0, 0), v.Uint(), 10); + if (quoted) { + e.Buffer.WriteByte(34); + } + e.Buffer.Write(b); + if (quoted) { + e.Buffer.WriteByte(34); + } + }; + floatEncoder.prototype.encode = function(e, v, quoted) { + var $ptr, b, bits, e, f, quoted, v; + v = v; + bits = this.$val; + f = v.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 = strconv.AppendFloat($subslice(new sliceType$2(e.scratch), 0, 0), f, 103, -1, (bits >> 0)); + if (quoted) { + e.Buffer.WriteByte(34); + } + e.Buffer.Write(b); + if (quoted) { + e.Buffer.WriteByte(34); + } + }; + $ptrType(floatEncoder).prototype.encode = function(e, v, quoted) { return new floatEncoder(this.$get()).encode(e, v, quoted); }; + stringEncoder = function(e, v, quoted) { + var $ptr, _r$2, _r$3, _r$4, _r$5, _r$6, _r$7, _tuple, e, err, numStr, quoted, sb, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _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; e = $f.e; err = $f.err; numStr = $f.numStr; quoted = $f.quoted; sb = $f.sb; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = v; + /* */ if ($interfaceIsEqual(v.Type(), numberType)) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if ($interfaceIsEqual(v.Type(), numberType)) { */ case 1: + _r$2 = v.String(); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + numStr = _r$2; + if (numStr === "") { + numStr = "0"; + } + /* */ if (!isValidNumber(numStr)) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (!isValidNumber(numStr)) { */ case 4: + _r$3 = fmt.Errorf("json: invalid number literal %q", new sliceType([new $String(numStr)])); /* */ $s = 6; case 6: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + $r = e.error(_r$3); /* */ $s = 7; case 7: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 5: + e.Buffer.WriteString(numStr); + return; + /* } */ case 2: + /* */ if (quoted) { $s = 8; continue; } + /* */ $s = 9; continue; + /* if (quoted) { */ case 8: + _r$4 = v.String(); /* */ $s = 11; case 11: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + _r$5 = Marshal(new $String(_r$4)); /* */ $s = 12; case 12: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + _tuple = _r$5; + sb = _tuple[0]; + err = _tuple[1]; + if (!($interfaceIsEqual(err, $ifaceNil))) { + e.error(err); + } + e.string($bytesToString(sb)); + $s = 10; continue; + /* } else { */ case 9: + _r$6 = v.String(); /* */ $s = 13; case 13: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + _r$7 = e.string(_r$6); /* */ $s = 14; case 14: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } + _r$7; + /* } */ case 10: + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: stringEncoder }; } $f.$ptr = $ptr; $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.e = e; $f.err = err; $f.numStr = numStr; $f.quoted = quoted; $f.sb = sb; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + interfaceEncoder = function(e, v, quoted) { + var $ptr, _r$2, e, quoted, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; e = $f.e; quoted = $f.quoted; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = v; + if (v.IsNil()) { + e.Buffer.WriteString("null"); + return; + } + _r$2 = v.Elem(); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + $r = e.reflectValue(_r$2); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: interfaceEncoder }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f.e = e; $f.quoted = quoted; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + unsupportedTypeEncoder = function(e, v, quoted) { + var $ptr, e, quoted, v; + v = v; + e.error(new UnsupportedTypeError.ptr(v.Type())); + }; + structEncoder.ptr.prototype.encode = function(e, v, quoted) { + var $ptr, _i, _r$2, _ref, e, f, first, fv, i, quoted, se, v, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r$2 = $f._r$2; _ref = $f._ref; e = $f.e; f = $f.f; first = $f.first; fv = $f.fv; i = $f.i; quoted = $f.quoted; se = $f.se; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = v; + se = this; + e.Buffer.WriteByte(123); + first = true; + _ref = se.fields; + _i = 0; + /* while (true) { */ case 1: + /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 2; continue; } + i = _i; + f = $clone(((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]), field); + _r$2 = fieldByIndex(v, f.index); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + fv = _r$2; + /* */ if (!fv.IsValid() || f.omitEmpty && isEmptyValue(fv)) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (!fv.IsValid() || f.omitEmpty && isEmptyValue(fv)) { */ case 4: + _i++; + /* continue; */ $s = 1; continue; + /* } */ case 5: + if (first) { + first = false; + } else { + e.Buffer.WriteByte(44); + } + e.string(f.name); + e.Buffer.WriteByte(58); + $r = (x = se.fieldEncs, ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]))(e, fv, f.quoted); /* */ $s = 6; case 6: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + _i++; + /* } */ $s = 1; continue; case 2: + e.Buffer.WriteByte(125); + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: structEncoder.ptr.prototype.encode }; } $f.$ptr = $ptr; $f._i = _i; $f._r$2 = _r$2; $f._ref = _ref; $f.e = e; $f.f = f; $f.first = first; $f.fv = fv; $f.i = i; $f.quoted = quoted; $f.se = se; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + structEncoder.prototype.encode = function(e, v, quoted) { return this.$val.encode(e, v, quoted); }; + newStructEncoder = function(t) { + var $ptr, _i, _r$2, _r$3, _r$4, _ref, f, fields, i, se, t, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _ref = $f._ref; f = $f.f; fields = $f.fields; i = $f.i; se = $f.se; t = $f.t; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r$2 = cachedTypeFields(t); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + fields = _r$2; + se = new structEncoder.ptr(fields, $makeSlice(sliceType$4, fields.$length)); + _ref = fields; + _i = 0; + /* while (true) { */ case 2: + /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 3; continue; } + i = _i; + f = $clone(((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]), field); + _r$3 = typeByIndex(t, f.index); /* */ $s = 4; case 4: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _r$4 = typeEncoder(_r$3); /* */ $s = 5; case 5: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + (x = se.fieldEncs, ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i] = _r$4)); + _i++; + /* } */ $s = 2; continue; case 3: + return $methodVal(se, "encode"); + /* */ } return; } if ($f === undefined) { $f = { $blk: newStructEncoder }; } $f.$ptr = $ptr; $f._i = _i; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._ref = _ref; $f.f = f; $f.fields = fields; $f.i = i; $f.se = se; $f.t = t; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + mapEncoder.ptr.prototype.encode = function(e, v, param) { + var $ptr, _arg, _arg$1, _i, _r$2, _r$3, _r$4, _r$5, _ref, e, i, k, me, param, sv, v, x, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _i = $f._i; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; _ref = $f._ref; e = $f.e; i = $f.i; k = $f.k; me = $f.me; param = $f.param; sv = $f.sv; v = $f.v; x = $f.x; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = v; + me = this; + if (v.IsNil()) { + e.Buffer.WriteString("null"); + return; + } + e.Buffer.WriteByte(123); + _r$2 = v.MapKeys(); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + sv = (x = _r$2, $subslice(new stringValues(x.$array), x.$offset, x.$offset + x.$length)); + $r = sort.Sort(sv); /* */ $s = 2; case 2: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + _ref = sv; + _i = 0; + /* while (true) { */ case 3: + /* if (!(_i < _ref.$length)) { break; } */ if(!(_i < _ref.$length)) { $s = 4; continue; } + i = _i; + k = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]); + if (i > 0) { + e.Buffer.WriteByte(44); + } + _r$3 = k.String(); /* */ $s = 5; case 5: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + _r$4 = e.string(_r$3); /* */ $s = 6; case 6: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + _r$4; + e.Buffer.WriteByte(58); + _arg = e; + _r$5 = v.MapIndex(k); /* */ $s = 7; case 7: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + _arg$1 = _r$5; + $r = me.elemEnc(_arg, _arg$1, false); /* */ $s = 8; case 8: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + _i++; + /* } */ $s = 3; continue; case 4: + e.Buffer.WriteByte(125); + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: mapEncoder.ptr.prototype.encode }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._i = _i; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f._ref = _ref; $f.e = e; $f.i = i; $f.k = k; $f.me = me; $f.param = param; $f.sv = sv; $f.v = v; $f.x = x; $f.$s = $s; $f.$r = $r; return $f; + }; + mapEncoder.prototype.encode = function(e, v, param) { return this.$val.encode(e, v, param); }; + newMapEncoder = function(t) { + var $ptr, _r$2, _r$3, _r$4, _r$5, me, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _r$5 = $f._r$5; me = $f.me; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r$2 = t.Key(); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _r$3 = _r$2.Kind(); /* */ $s = 4; case 4: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + /* */ if (!((_r$3 === 24))) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (!((_r$3 === 24))) { */ case 1: + return unsupportedTypeEncoder; + /* } */ case 2: + _r$4 = t.Elem(); /* */ $s = 5; case 5: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + _r$5 = typeEncoder(_r$4); /* */ $s = 6; case 6: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + me = new mapEncoder.ptr(_r$5); + return $methodVal(me, "encode"); + /* */ } return; } if ($f === undefined) { $f = { $blk: newMapEncoder }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._r$5 = _r$5; $f.me = me; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + encodeByteSlice = function(e, v, param) { + var $ptr, _r$2, _r$3, _r$4, dst, e, enc, param, s, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; dst = $f.dst; e = $f.e; enc = $f.enc; param = $f.param; s = $f.s; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = v; + if (v.IsNil()) { + e.Buffer.WriteString("null"); + return; + } + _r$2 = v.Bytes(); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + s = _r$2; + e.Buffer.WriteByte(34); + /* */ if (s.$length < 1024) { $s = 2; continue; } + /* */ $s = 3; continue; + /* if (s.$length < 1024) { */ case 2: + dst = $makeSlice(sliceType$2, base64.StdEncoding.EncodedLen(s.$length)); + base64.StdEncoding.Encode(dst, s); + e.Buffer.Write(dst); + $s = 4; continue; + /* } else { */ case 3: + enc = base64.NewEncoder(base64.StdEncoding, e); + _r$3 = enc.Write(s); /* */ $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 = enc.Close(); /* */ $s = 6; case 6: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + _r$4; + /* } */ case 4: + e.Buffer.WriteByte(34); + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: encodeByteSlice }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f.dst = dst; $f.e = e; $f.enc = enc; $f.param = param; $f.s = s; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + sliceEncoder.ptr.prototype.encode = function(e, v, param) { + var $ptr, e, param, se, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; e = $f.e; param = $f.param; se = $f.se; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = v; + se = this; + if (v.IsNil()) { + e.Buffer.WriteString("null"); + return; + } + $r = se.arrayEnc(e, v, false); /* */ $s = 1; case 1: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: sliceEncoder.ptr.prototype.encode }; } $f.$ptr = $ptr; $f.e = e; $f.param = param; $f.se = se; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + sliceEncoder.prototype.encode = function(e, v, param) { return this.$val.encode(e, v, param); }; + newSliceEncoder = function(t) { + var $ptr, _r$2, _r$3, _r$4, enc, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _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$2 = t.Elem(); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _r$3 = _r$2.Kind(); /* */ $s = 4; case 4: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + /* */ if (_r$3 === 8) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (_r$3 === 8) { */ case 1: + return encodeByteSlice; + /* } */ case 2: + _r$4 = newArrayEncoder(t); /* */ $s = 5; case 5: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + enc = new sliceEncoder.ptr(_r$4); + return $methodVal(enc, "encode"); + /* */ } return; } if ($f === undefined) { $f = { $blk: newSliceEncoder }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f.enc = enc; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + arrayEncoder.ptr.prototype.encode = function(e, v, param) { + var $ptr, _arg, _arg$1, _r$2, ae, e, i, n, param, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _r$2 = $f._r$2; ae = $f.ae; e = $f.e; i = $f.i; n = $f.n; param = $f.param; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = v; + ae = this; + e.Buffer.WriteByte(91); + n = v.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$2 = v.Index(i); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _arg$1 = _r$2; + $r = ae.elemEnc(_arg, _arg$1, false); /* */ $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; case -1: } return; } if ($f === undefined) { $f = { $blk: arrayEncoder.ptr.prototype.encode }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._r$2 = _r$2; $f.ae = ae; $f.e = e; $f.i = i; $f.n = n; $f.param = param; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + arrayEncoder.prototype.encode = function(e, v, param) { return this.$val.encode(e, v, param); }; + newArrayEncoder = function(t) { + var $ptr, _r$2, _r$3, enc, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; enc = $f.enc; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r$2 = t.Elem(); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _r$3 = typeEncoder(_r$2); /* */ $s = 2; case 2: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + enc = new arrayEncoder.ptr(_r$3); + return $methodVal(enc, "encode"); + /* */ } return; } if ($f === undefined) { $f = { $blk: newArrayEncoder }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $f.enc = enc; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + ptrEncoder.ptr.prototype.encode = function(e, v, quoted) { + var $ptr, _arg, _arg$1, _arg$2, _r$2, e, pe, quoted, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _arg = $f._arg; _arg$1 = $f._arg$1; _arg$2 = $f._arg$2; _r$2 = $f._r$2; e = $f.e; pe = $f.pe; quoted = $f.quoted; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = v; + pe = this; + if (v.IsNil()) { + e.Buffer.WriteString("null"); + return; + } + _arg = e; + _r$2 = v.Elem(); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _arg$1 = _r$2; + _arg$2 = quoted; + $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; case -1: } return; } if ($f === undefined) { $f = { $blk: ptrEncoder.ptr.prototype.encode }; } $f.$ptr = $ptr; $f._arg = _arg; $f._arg$1 = _arg$1; $f._arg$2 = _arg$2; $f._r$2 = _r$2; $f.e = e; $f.pe = pe; $f.quoted = quoted; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + ptrEncoder.prototype.encode = function(e, v, quoted) { return this.$val.encode(e, v, quoted); }; + newPtrEncoder = function(t) { + var $ptr, _r$2, _r$3, enc, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; enc = $f.enc; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + _r$2 = t.Elem(); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _r$3 = typeEncoder(_r$2); /* */ $s = 2; case 2: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + enc = new ptrEncoder.ptr(_r$3); + return $methodVal(enc, "encode"); + /* */ } return; } if ($f === undefined) { $f = { $blk: newPtrEncoder }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $f.enc = enc; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + condAddrEncoder.ptr.prototype.encode = function(e, v, quoted) { + var $ptr, ce, e, quoted, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; ce = $f.ce; e = $f.e; quoted = $f.quoted; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = v; + ce = this; + /* */ if (v.CanAddr()) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (v.CanAddr()) { */ case 1: + $r = ce.canAddrEnc(e, v, quoted); /* */ $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, v, quoted); /* */ $s = 5; case 5: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + /* } */ case 3: + /* */ $s = -1; case -1: } return; } if ($f === undefined) { $f = { $blk: condAddrEncoder.ptr.prototype.encode }; } $f.$ptr = $ptr; $f.ce = ce; $f.e = e; $f.quoted = quoted; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + condAddrEncoder.prototype.encode = function(e, v, quoted) { return this.$val.encode(e, v, quoted); }; + newCondAddrEncoder = function(canAddrEnc, elseEnc) { + var $ptr, canAddrEnc, elseEnc, enc; + enc = new condAddrEncoder.ptr(canAddrEnc, elseEnc); + return $methodVal(enc, "encode"); + }; + isValidTag = function(s) { + var $ptr, _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; + }; + fieldByIndex = function(v, index) { + var $ptr, _i, _r$2, _r$3, _ref, i, index, v, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r$2 = $f._r$2; _r$3 = $f._r$3; _ref = $f._ref; i = $f.i; index = $f.index; v = $f.v; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + v = v; + _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") : _ref.$array[_ref.$offset + _i]); + /* */ if (v.Kind() === 22) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (v.Kind() === 22) { */ case 3: + if (v.IsNil()) { + return new reflect.Value.ptr(ptrType$2.nil, 0, 0); + } + _r$2 = v.Elem(); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + v = _r$2; + /* } */ case 4: + _r$3 = v.Field(i); /* */ $s = 6; case 6: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + v = _r$3; + _i++; + /* } */ $s = 1; continue; case 2: + return v; + /* */ } return; } if ($f === undefined) { $f = { $blk: fieldByIndex }; } $f.$ptr = $ptr; $f._i = _i; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._ref = _ref; $f.i = i; $f.index = index; $f.v = v; $f.$s = $s; $f.$r = $r; return $f; + }; + typeByIndex = function(t, index) { + var $ptr, _i, _r$2, _r$3, _r$4, _ref, i, index, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _i = $f._i; _r$2 = $f._r$2; _r$3 = $f._r$3; _r$4 = $f._r$4; _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") : _ref.$array[_ref.$offset + _i]); + _r$2 = t.Kind(); /* */ $s = 5; case 5: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + /* */ if (_r$2 === 22) { $s = 3; continue; } + /* */ $s = 4; continue; + /* if (_r$2 === 22) { */ case 3: + _r$3 = t.Elem(); /* */ $s = 6; case 6: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + t = _r$3; + /* } */ case 4: + _r$4 = t.Field(i); /* */ $s = 7; case 7: if($c) { $c = false; _r$4 = _r$4.$blk(); } if (_r$4 && _r$4.$blk !== undefined) { break s; } + t = _r$4.Type; + _i++; + /* } */ $s = 1; continue; case 2: + return t; + /* */ } return; } if ($f === undefined) { $f = { $blk: typeByIndex }; } $f.$ptr = $ptr; $f._i = _i; $f._r$2 = _r$2; $f._r$3 = _r$3; $f._r$4 = _r$4; $f._ref = _ref; $f.i = i; $f.index = index; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + stringValues.prototype.Len = function() { + var $ptr, sv; + sv = this; + return sv.$length; + }; + $ptrType(stringValues).prototype.Len = function() { return this.$get().Len(); }; + stringValues.prototype.Swap = function(i, j) { + var $ptr, _tmp, _tmp$1, i, j, sv; + sv = this; + _tmp = ((j < 0 || j >= sv.$length) ? $throwRuntimeError("index out of range") : sv.$array[sv.$offset + j]); + _tmp$1 = ((i < 0 || i >= sv.$length) ? $throwRuntimeError("index out of range") : sv.$array[sv.$offset + i]); + ((i < 0 || i >= sv.$length) ? $throwRuntimeError("index out of range") : sv.$array[sv.$offset + i] = _tmp); + ((j < 0 || j >= sv.$length) ? $throwRuntimeError("index out of range") : sv.$array[sv.$offset + j] = _tmp$1); + }; + $ptrType(stringValues).prototype.Swap = function(i, j) { return this.$get().Swap(i, j); }; + stringValues.prototype.Less = function(i, j) { + var $ptr, _r$2, _r$3, i, j, sv, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; _r$3 = $f._r$3; i = $f.i; j = $f.j; sv = $f.sv; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + sv = this; + _r$2 = sv.get(i); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _r$3 = sv.get(j); /* */ $s = 2; case 2: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + /* */ $s = 3; case 3: + return _r$2 < _r$3; + /* */ } return; } if ($f === undefined) { $f = { $blk: stringValues.prototype.Less }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f._r$3 = _r$3; $f.i = i; $f.j = j; $f.sv = sv; $f.$s = $s; $f.$r = $r; return $f; + }; + $ptrType(stringValues).prototype.Less = function(i, j) { return this.$get().Less(i, j); }; + stringValues.prototype.get = function(i) { + var $ptr, _r$2, i, sv, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; i = $f.i; sv = $f.sv; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + sv = this; + _r$2 = ((i < 0 || i >= sv.$length) ? $throwRuntimeError("index out of range") : sv.$array[sv.$offset + i]).String(); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + /* */ $s = 2; case 2: + return _r$2; + /* */ } return; } if ($f === undefined) { $f = { $blk: stringValues.prototype.get }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $f.i = i; $f.sv = sv; $f.$s = $s; $f.$r = $r; return $f; + }; + $ptrType(stringValues).prototype.get = function(i) { return this.$get().get(i); }; + encodeState.ptr.prototype.string = function(s) { + var $ptr, _3, _tuple, b, c, e, i, len0, s, size, start; + e = this; + len0 = e.Buffer.Len(); + e.Buffer.WriteByte(34); + start = 0; + i = 0; + while (true) { + if (!(i < s.length)) { break; } + b = s.charCodeAt(i); + if (b < 128) { + if (32 <= b && !((b === 92)) && !((b === 34)) && !((b === 60)) && !((b === 62)) && !((b === 38))) { + i = i + (1) >> 0; + continue; + } + if (start < i) { + e.Buffer.WriteString(s.substring(start, i)); + } + _3 = b; + if ((_3 === (92)) || (_3 === (34))) { + e.Buffer.WriteByte(92); + e.Buffer.WriteByte(b); + } else if (_3 === (10)) { + e.Buffer.WriteByte(92); + e.Buffer.WriteByte(110); + } else if (_3 === (13)) { + e.Buffer.WriteByte(92); + e.Buffer.WriteByte(114); + } else if (_3 === (9)) { + e.Buffer.WriteByte(92); + 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(s.substring(i)); + c = _tuple[0]; + size = _tuple[1]; + if ((c === 65533) && (size === 1)) { + if (start < i) { + e.Buffer.WriteString(s.substring(start, i)); + } + e.Buffer.WriteString("\\ufffd"); + i = i + (size) >> 0; + start = i; + continue; + } + if ((c === 8232) || (c === 8233)) { + if (start < i) { + e.Buffer.WriteString(s.substring(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(s.substring(start)); + } + e.Buffer.WriteByte(34); + return e.Buffer.Len() - len0 >> 0; + }; + encodeState.prototype.string = function(s) { return this.$val.string(s); }; + encodeState.ptr.prototype.stringBytes = function(s) { + var $ptr, _4, _tuple, b, c, e, i, len0, s, size, start; + e = this; + len0 = e.Buffer.Len(); + 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") : s.$array[s.$offset + i]); + if (b < 128) { + if (32 <= b && !((b === 92)) && !((b === 34)) && !((b === 60)) && !((b === 62)) && !((b === 38))) { + i = i + (1) >> 0; + continue; + } + if (start < i) { + e.Buffer.Write($subslice(s, start, i)); + } + _4 = b; + if ((_4 === (92)) || (_4 === (34))) { + e.Buffer.WriteByte(92); + e.Buffer.WriteByte(b); + } else if (_4 === (10)) { + e.Buffer.WriteByte(92); + e.Buffer.WriteByte(110); + } else if (_4 === (13)) { + e.Buffer.WriteByte(92); + e.Buffer.WriteByte(114); + } else if (_4 === (9)) { + e.Buffer.WriteByte(92); + 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); + return e.Buffer.Len() - len0 >> 0; + }; + encodeState.prototype.stringBytes = function(s) { return this.$val.stringBytes(s); }; + fillField = function(f) { + var $ptr, f; + f = $clone(f, field); + f.nameBytes = new sliceType$2($stringToBytes(f.name)); + f.equalFold = foldFunc(f.nameBytes); + return f; + }; + byName.prototype.Len = function() { + var $ptr, x; + x = this; + return x.$length; + }; + $ptrType(byName).prototype.Len = function() { return this.$get().Len(); }; + byName.prototype.Swap = function(i, j) { + var $ptr, _tmp, _tmp$1, i, j, x; + x = this; + _tmp = $clone(((j < 0 || j >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + j]), field); + _tmp$1 = $clone(((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]), field); + field.copy(((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]), _tmp); + field.copy(((j < 0 || j >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + j]), _tmp$1); + }; + $ptrType(byName).prototype.Swap = function(i, j) { return this.$get().Swap(i, j); }; + byName.prototype.Less = function(i, j) { + var $ptr, i, j, x; + x = this; + if (!(((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]).name === ((j < 0 || j >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + j]).name)) { + return ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]).name < ((j < 0 || j >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + j]).name; + } + if (!((((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]).index.$length === ((j < 0 || j >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + j]).index.$length))) { + return ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]).index.$length < ((j < 0 || j >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + j]).index.$length; + } + if (!(((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]).tag === ((j < 0 || j >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + j]).tag)) { + return ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]).tag; + } + return $subslice(new byIndex(x.$array), x.$offset, x.$offset + x.$length).Less(i, j); + }; + $ptrType(byName).prototype.Less = function(i, j) { return this.$get().Less(i, j); }; + byIndex.prototype.Len = function() { + var $ptr, x; + x = this; + return x.$length; + }; + $ptrType(byIndex).prototype.Len = function() { return this.$get().Len(); }; + byIndex.prototype.Swap = function(i, j) { + var $ptr, _tmp, _tmp$1, i, j, x; + x = this; + _tmp = $clone(((j < 0 || j >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + j]), field); + _tmp$1 = $clone(((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]), field); + field.copy(((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]), _tmp); + field.copy(((j < 0 || j >= x.$length) ? $throwRuntimeError("index out of range") : 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 $ptr, _i, _ref, i, j, k, x, x$1, x$2, xik; + x = this; + _ref = ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : 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") : _ref.$array[_ref.$offset + _i]); + if (k >= ((j < 0 || j >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + j]).index.$length) { + return false; + } + if (!((xik === (x$1 = ((j < 0 || j >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + j]).index, ((k < 0 || k >= x$1.$length) ? $throwRuntimeError("index out of range") : x$1.$array[x$1.$offset + k]))))) { + return xik < (x$2 = ((j < 0 || j >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + j]).index, ((k < 0 || k >= x$2.$length) ? $throwRuntimeError("index out of range") : x$2.$array[x$2.$offset + k])); + } + _i++; + } + return ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i]).index.$length < ((j < 0 || j >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + j]).index.$length; + }; + $ptrType(byIndex).prototype.Less = function(i, j) { return this.$get().Less(i, j); }; + typeFields = function(t) { + var $ptr, _5, _entry, _entry$1, _entry$2, _entry$3, _i, _key, _key$1, _r$10, _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, _v, _v$1, advance, count, current, dominant, f, fi, fields, fj, ft, i, i$1, index, name, name$1, next, nextCount, ok, opts, out, quoted, sf, t, 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; $ptr = $f.$ptr; _5 = $f._5; _entry = $f._entry; _entry$1 = $f._entry$1; _entry$2 = $f._entry$2; _entry$3 = $f._entry$3; _i = $f._i; _key = $f._key; _key$1 = $f._key$1; _r$10 = $f._r$10; _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; _v = $f._v; _v$1 = $f._v$1; advance = $f.advance; count = $f.count; current = $f.current; dominant = $f.dominant; f = $f.f; fi = $f.fi; fields = $f.fields; fj = $f.fj; ft = $f.ft; i = $f.i; i$1 = $f.i$1; index = $f.index; name = $f.name; name$1 = $f.name$1; next = $f.next; nextCount = $f.nextCount; ok = $f.ok; opts = $f.opts; out = $f.out; quoted = $f.quoted; sf = $f.sf; t = $f.t; 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: + current = new sliceType$1([]); + next = new sliceType$1([new field.ptr("", sliceType$2.nil, $throwNilPointerError, false, sliceType$3.nil, t, false, false)]); + count = $makeMap(reflect.Type.keyFor, []); + nextCount = $makeMap(reflect.Type.keyFor, []); + visited = $makeMap(reflect.Type.keyFor, []); + fields = sliceType$1.nil; + /* 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") : _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$2 = f.typ.NumField(); /* */ $s = 9; case 9: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + /* if (!(i < _r$2)) { break; } */ if(!(i < _r$2)) { $s = 8; continue; } + _r$3 = f.typ.Field(i); /* */ $s = 10; case 10: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + sf = $clone(_r$3, reflect.StructField); + /* */ if (!(sf.PkgPath === "") && !sf.Anonymous) { $s = 11; continue; } + /* */ $s = 12; continue; + /* if (!(sf.PkgPath === "") && !sf.Anonymous) { */ case 11: + i = i + (1) >> 0; + /* continue; */ $s = 7; continue; + /* } */ case 12: + tag = new reflect.StructTag(sf.Tag).Get("json"); + /* */ if (tag === "-") { $s = 13; continue; } + /* */ $s = 14; continue; + /* if (tag === "-") { */ case 13: + i = i + (1) >> 0; + /* continue; */ $s = 7; continue; + /* } */ case 14: + _tuple = parseTag(tag); + name = _tuple[0]; + opts = _tuple[1]; + if (!isValidTag(name)) { + name = ""; + } + index = $makeSlice(sliceType$3, (f.index.$length + 1 >> 0)); + $copySlice(index, f.index); + (x = f.index.$length, ((x < 0 || x >= index.$length) ? $throwRuntimeError("index out of range") : index.$array[index.$offset + x] = i)); + ft = sf.Type; + _r$4 = ft.Name(); /* */ $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 === "")) { _v = false; $s = 17; continue s; } + _r$5 = ft.Kind(); /* */ $s = 19; case 19: if($c) { $c = false; _r$5 = _r$5.$blk(); } if (_r$5 && _r$5.$blk !== undefined) { break s; } + _v = _r$5 === 22; case 17: + /* */ if (_v) { $s = 15; continue; } + /* */ $s = 16; continue; + /* if (_v) { */ case 15: + _r$6 = ft.Elem(); /* */ $s = 20; case 20: if($c) { $c = false; _r$6 = _r$6.$blk(); } if (_r$6 && _r$6.$blk !== undefined) { break s; } + ft = _r$6; + /* } */ case 16: + quoted = false; + /* */ if (new tagOptions(opts).Contains("string")) { $s = 21; continue; } + /* */ $s = 22; continue; + /* if (new tagOptions(opts).Contains("string")) { */ case 21: + _r$7 = ft.Kind(); /* */ $s = 24; case 24: if($c) { $c = false; _r$7 = _r$7.$blk(); } if (_r$7 && _r$7.$blk !== undefined) { break s; } + _5 = _r$7; + if ((_5 === (1)) || (_5 === (2)) || (_5 === (3)) || (_5 === (4)) || (_5 === (5)) || (_5 === (6)) || (_5 === (7)) || (_5 === (8)) || (_5 === (9)) || (_5 === (10)) || (_5 === (11)) || (_5 === (13)) || (_5 === (14)) || (_5 === (24))) { + quoted = true; + } + case 23: + /* } */ case 22: + if (!(name === "") || !sf.Anonymous) { _v$1 = true; $s = 27; continue s; } + _r$8 = ft.Kind(); /* */ $s = 28; case 28: if($c) { $c = false; _r$8 = _r$8.$blk(); } if (_r$8 && _r$8.$blk !== undefined) { break s; } + _v$1 = !((_r$8 === 25)); case 27: + /* */ if (_v$1) { $s = 25; continue; } + /* */ $s = 26; continue; + /* if (_v$1) { */ case 25: + tagged = !(name === ""); + if (name === "") { + name = sf.Name; + } + fields = $append(fields, fillField(new field.ptr(name, sliceType$2.nil, $throwNilPointerError, tagged, index, ft, new tagOptions(opts).Contains("omitempty"), quoted))); + if ((_entry$1 = count[reflect.Type.keyFor(f.typ)], _entry$1 !== undefined ? _entry$1.v : 0) > 1) { + fields = $append(fields, (x$1 = fields.$length - 1 >> 0, ((x$1 < 0 || x$1 >= fields.$length) ? $throwRuntimeError("index out of range") : fields.$array[fields.$offset + x$1]))); + } + i = i + (1) >> 0; + /* continue; */ $s = 7; continue; + /* } */ case 26: + _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 = 29; continue; } + /* */ $s = 30; continue; + /* if ((_entry$3 = nextCount[reflect.Type.keyFor(ft)], _entry$3 !== undefined ? _entry$3.v : 0) === 1) { */ case 29: + _r$9 = ft.Name(); /* */ $s = 31; case 31: if($c) { $c = false; _r$9 = _r$9.$blk(); } if (_r$9 && _r$9.$blk !== undefined) { break s; } + _r$10 = fillField(new field.ptr(_r$9, sliceType$2.nil, $throwNilPointerError, false, index, ft, false, false)); /* */ $s = 32; case 32: if($c) { $c = false; _r$10 = _r$10.$blk(); } if (_r$10 && _r$10.$blk !== undefined) { break s; } + next = $append(next, _r$10); + /* } */ case 30: + i = i + (1) >> 0; + /* } */ $s = 7; continue; case 8: + _i++; + /* } */ $s = 3; continue; case 4: + /* } */ $s = 1; continue; case 2: + $r = sort.Sort($subslice(new byName(fields.$array), fields.$offset, fields.$offset + fields.$length)); /* */ $s = 33; case 33: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + out = $subslice(fields, 0, 0); + _tmp$4 = 0; + _tmp$5 = 0; + advance = _tmp$4; + i$1 = _tmp$5; + /* while (true) { */ case 34: + /* if (!(i$1 < fields.$length)) { break; } */ if(!(i$1 < fields.$length)) { $s = 35; continue; } + fi = $clone(((i$1 < 0 || i$1 >= fields.$length) ? $throwRuntimeError("index out of range") : fields.$array[fields.$offset + i$1]), field); + name$1 = fi.name; + advance = 1; + while (true) { + if (!((i$1 + advance >> 0) < fields.$length)) { break; } + fj = $clone((x$2 = i$1 + advance >> 0, ((x$2 < 0 || x$2 >= fields.$length) ? $throwRuntimeError("index out of range") : fields.$array[fields.$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 = 34; continue; + } + _tuple$1 = dominantField($subslice(fields, 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 = 34; continue; case 35: + fields = out; + $r = sort.Sort($subslice(new byIndex(fields.$array), fields.$offset, fields.$offset + fields.$length)); /* */ $s = 36; case 36: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + return fields; + /* */ } return; } if ($f === undefined) { $f = { $blk: typeFields }; } $f.$ptr = $ptr; $f._5 = _5; $f._entry = _entry; $f._entry$1 = _entry$1; $f._entry$2 = _entry$2; $f._entry$3 = _entry$3; $f._i = _i; $f._key = _key; $f._key$1 = _key$1; $f._r$10 = _r$10; $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._v = _v; $f._v$1 = _v$1; $f.advance = advance; $f.count = count; $f.current = current; $f.dominant = dominant; $f.f = f; $f.fi = fi; $f.fields = fields; $f.fj = fj; $f.ft = ft; $f.i = i; $f.i$1 = i$1; $f.index = index; $f.name = name; $f.name$1 = name$1; $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.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 $ptr, _i, _ref, f, fields, i, length, tagged; + length = (0 >= fields.$length ? $throwRuntimeError("index out of range") : fields.$array[fields.$offset + 0]).index.$length; + tagged = -1; + _ref = fields; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + f = $clone(((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]), field); + if (f.index.$length > length) { + fields = $subslice(fields, 0, i); + break; + } + if (f.tag) { + if (tagged >= 0) { + return [new field.ptr("", sliceType$2.nil, $throwNilPointerError, false, sliceType$3.nil, $ifaceNil, false, false), false]; + } + tagged = i; + } + _i++; + } + if (tagged >= 0) { + return [((tagged < 0 || tagged >= fields.$length) ? $throwRuntimeError("index out of range") : fields.$array[fields.$offset + tagged]), true]; + } + if (fields.$length > 1) { + return [new field.ptr("", sliceType$2.nil, $throwNilPointerError, false, sliceType$3.nil, $ifaceNil, false, false), false]; + } + return [(0 >= fields.$length ? $throwRuntimeError("index out of range") : fields.$array[fields.$offset + 0]), true]; + }; + cachedTypeFields = function(t) { + var $ptr, _entry, _key, _r$2, f, t, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _entry = $f._entry; _key = $f._key; _r$2 = $f._r$2; f = $f.f; t = $f.t; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + fieldCache.RWMutex.RLock(); + f = (_entry = fieldCache.m[reflect.Type.keyFor(t)], _entry !== undefined ? _entry.v : sliceType$1.nil); + fieldCache.RWMutex.RUnlock(); + if (!(f === sliceType$1.nil)) { + return f; + } + _r$2 = typeFields(t); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + f = _r$2; + if (f === sliceType$1.nil) { + f = new sliceType$1([]); + } + fieldCache.RWMutex.Lock(); + if (fieldCache.m === false) { + fieldCache.m = $makeMap(reflect.Type.keyFor, []); + } + _key = t; (fieldCache.m || $throwRuntimeError("assignment to entry in nil map"))[reflect.Type.keyFor(_key)] = { k: _key, v: f }; + fieldCache.RWMutex.Unlock(); + return f; + /* */ } return; } if ($f === undefined) { $f = { $blk: cachedTypeFields }; } $f.$ptr = $ptr; $f._entry = _entry; $f._key = _key; $f._r$2 = _r$2; $f.f = f; $f.t = t; $f.$s = $s; $f.$r = $r; return $f; + }; + foldFunc = function(s) { + var $ptr, _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") : _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 $ptr, _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") : _ref.$array[_ref.$offset + _i]); + if (t.$length === 0) { + return false; + } + tb = (0 >= t.$length ? $throwRuntimeError("index out of range") : 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 $ptr, _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") : _ref.$array[_ref.$offset + _i]); + tb = ((i < 0 || i >= t.$length) ? $throwRuntimeError("index out of range") : 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 $ptr, _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") : _ref.$array[_ref.$offset + _i]); + if (!((((b & 223) >>> 0) === ((((i < 0 || i >= t.$length) ? $throwRuntimeError("index out of range") : t.$array[t.$offset + i]) & 223) >>> 0)))) { + return false; + } + _i++; + } + return true; + }; + compact = function(dst, src, escape) { + var $ptr, _i, _r$2, _r$3, _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; $ptr = $f.$ptr; _i = $f._i; _r$2 = $f._r$2; _r$3 = $f._r$3; _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$3.nil, $ifaceNil, false, 0, $throwNilPointerError, 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") : _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") : src.$array[src.$offset + x])) === 128) && ((((x$1 = i + 2 >> 0, ((x$1 < 0 || x$1 >= src.$length) ? $throwRuntimeError("index out of range") : 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") : src.$array[src.$offset + x$2])) & 15) >>> 0))); + start = i + 3 >> 0; + } + _r$2 = scan[0].step(scan[0], c); /* */ $s = 3; case 3: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + v = _r$2; + 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$3 = scan[0].eof(); /* */ $s = 6; case 6: if($c) { $c = false; _r$3 = _r$3.$blk(); } if (_r$3 && _r$3.$blk !== undefined) { break s; } + /* */ if (_r$3 === 11) { $s = 4; continue; } + /* */ $s = 5; continue; + /* if (_r$3 === 11) { */ case 4: + dst.Truncate(origLen); + return scan[0].err; + /* } */ case 5: + if (start < src.$length) { + dst.Write($subslice(src, start)); + } + return $ifaceNil; + /* */ } return; } if ($f === undefined) { $f = { $blk: compact }; } $f.$ptr = $ptr; $f._i = _i; $f._r$2 = _r$2; $f._r$3 = _r$3; $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 $ptr, e; + e = this; + return e.msg; + }; + SyntaxError.prototype.Error = function() { return this.$val.Error(); }; + scanner.ptr.prototype.reset = function() { + var $ptr, s; + s = this; + s.step = stateBeginValue; + s.parseState = $subslice(s.parseState, 0, 0); + s.err = $ifaceNil; + s.redo = false; + s.endTop = false; + }; + scanner.prototype.reset = function() { return this.$val.reset(); }; + scanner.ptr.prototype.eof = function() { + var $ptr, _r$2, s, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r$2 = $f._r$2; s = $f.s; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + s = this; + if (!($interfaceIsEqual(s.err, $ifaceNil))) { + return 11; + } + if (s.endTop) { + return 10; + } + _r$2 = s.step(s, 32); /* */ $s = 1; case 1: if($c) { $c = false; _r$2 = _r$2.$blk(); } if (_r$2 && _r$2.$blk !== undefined) { break s; } + _r$2; + if (s.endTop) { + return 10; + } + if ($interfaceIsEqual(s.err, $ifaceNil)) { + s.err = new SyntaxError.ptr("unexpected end of JSON input", s.bytes); + } + return 11; + /* */ } return; } if ($f === undefined) { $f = { $blk: scanner.ptr.prototype.eof }; } $f.$ptr = $ptr; $f._r$2 = _r$2; $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 $ptr, 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 $ptr, n, s; + s = this; + n = s.parseState.$length - 1 >> 0; + s.parseState = $subslice(s.parseState, 0, n); + s.redo = false; + 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 $ptr, c; + return (c === 32) || (c === 9) || (c === 13) || (c === 10); + }; + stateBeginValueOrEmpty = function(s, c) { + var $ptr, 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 $ptr, _2, c, s; + if (c <= 32 && isSpace(c)) { + return 9; + } + _2 = c; + if (_2 === (123)) { + s.step = stateBeginStringOrEmpty; + s.pushParseState(0); + return 2; + } else if (_2 === (91)) { + s.step = stateBeginValueOrEmpty; + s.pushParseState(2); + return 6; + } else if (_2 === (34)) { + s.step = stateInString; + return 1; + } else if (_2 === (45)) { + s.step = stateNeg; + return 1; + } else if (_2 === (48)) { + s.step = state0; + return 1; + } else if (_2 === (116)) { + s.step = stateT; + return 1; + } else if (_2 === (102)) { + s.step = stateF; + return 1; + } else if (_2 === (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 $ptr, 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") : x.$array[x.$offset + x$1] = 1)); + return stateEndValue(s, c); + } + return stateBeginString(s, c); + }; + stateBeginString = function(s, c) { + var $ptr, 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 $ptr, _3, 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") : x.$array[x.$offset + x$1])); + _3 = ps; + if (_3 === (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") : x$2.$array[x$2.$offset + x$3] = 1)); + s.step = stateBeginValue; + return 3; + } + return s.error(c, "after object key"); + } else if (_3 === (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") : 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 (_3 === (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 $ptr, c, s; + if (!((c === 32)) && !((c === 9)) && !((c === 13)) && !((c === 10))) { + s.error(c, "after top-level value"); + } + return 10; + }; + stateInString = function(s, c) { + var $ptr, 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 $ptr, _4, c, s; + _4 = c; + if ((_4 === (98)) || (_4 === (102)) || (_4 === (110)) || (_4 === (114)) || (_4 === (116)) || (_4 === (92)) || (_4 === (47)) || (_4 === (34))) { + s.step = stateInString; + return 0; + } else if (_4 === (117)) { + s.step = stateInStringEscU; + return 0; + } + return s.error(c, "in string escape code"); + }; + stateInStringEscU = function(s, c) { + var $ptr, 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 $ptr, 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 $ptr, 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 $ptr, 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 $ptr, 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 $ptr, c, s; + if (48 <= c && c <= 57) { + s.step = state1; + return 0; + } + return state0(s, c); + }; + state0 = function(s, c) { + var $ptr, 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 $ptr, 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 $ptr, 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 $ptr, c, s; + if ((c === 43) || (c === 45)) { + s.step = stateESign; + return 0; + } + return stateESign(s, c); + }; + stateESign = function(s, c) { + var $ptr, 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 $ptr, c, s; + if (48 <= c && c <= 57) { + return 0; + } + return stateEndValue(s, c); + }; + stateT = function(s, c) { + var $ptr, c, s; + if (c === 114) { + s.step = stateTr; + return 0; + } + return s.error(c, "in literal true (expecting 'r')"); + }; + stateTr = function(s, c) { + var $ptr, c, s; + if (c === 117) { + s.step = stateTru; + return 0; + } + return s.error(c, "in literal true (expecting 'u')"); + }; + stateTru = function(s, c) { + var $ptr, c, s; + if (c === 101) { + s.step = stateEndValue; + return 0; + } + return s.error(c, "in literal true (expecting 'e')"); + }; + stateF = function(s, c) { + var $ptr, c, s; + if (c === 97) { + s.step = stateFa; + return 0; + } + return s.error(c, "in literal false (expecting 'a')"); + }; + stateFa = function(s, c) { + var $ptr, c, s; + if (c === 108) { + s.step = stateFal; + return 0; + } + return s.error(c, "in literal false (expecting 'l')"); + }; + stateFal = function(s, c) { + var $ptr, c, s; + if (c === 115) { + s.step = stateFals; + return 0; + } + return s.error(c, "in literal false (expecting 's')"); + }; + stateFals = function(s, c) { + var $ptr, c, s; + if (c === 101) { + s.step = stateEndValue; + return 0; + } + return s.error(c, "in literal false (expecting 'e')"); + }; + stateN = function(s, c) { + var $ptr, c, s; + if (c === 117) { + s.step = stateNu; + return 0; + } + return s.error(c, "in literal null (expecting 'u')"); + }; + stateNu = function(s, c) { + var $ptr, c, s; + if (c === 108) { + s.step = stateNul; + return 0; + } + return s.error(c, "in literal null (expecting 'l')"); + }; + stateNul = function(s, c) { + var $ptr, c, s; + if (c === 108) { + s.step = stateEndValue; + return 0; + } + return s.error(c, "in literal null (expecting 'l')"); + }; + stateError = function(s, c) { + var $ptr, c, s; + return 11; + }; + scanner.ptr.prototype.error = function(c, context) { + var $ptr, 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 $ptr, c, s; + if (c === 39) { + return "'\\''"; + } + if (c === 34) { + return "'\"'"; + } + s = strconv.Quote($encodeRune(c)); + return "'" + s.substring(1, (s.length - 1 >> 0)) + "'"; + }; + parseTag = function(tag) { + var $ptr, idx, tag; + idx = strings.Index(tag, ","); + if (!((idx === -1))) { + return [tag.substring(0, idx), tag.substring((idx + 1 >> 0))]; + } + return [tag, ""]; + }; + tagOptions.prototype.Contains = function(optionName) { + var $ptr, _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 = s.substring(0, i); + _tmp$1 = s.substring((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$13.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}]; + ptrType$14.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}]; + ptrType$16.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}]; + ptrType$4.methods = [{prop: "marshal", name: "marshal", pkg: "encoding/json", typ: $funcType([$emptyInterface], [$error], false)}, {prop: "error", name: "error", pkg: "encoding/json", typ: $funcType([$error], [], false)}, {prop: "reflectValue", name: "reflectValue", pkg: "encoding/json", typ: $funcType([reflect.Value], [], false)}, {prop: "string", name: "string", pkg: "encoding/json", typ: $funcType([$String], [$Int], false)}, {prop: "stringBytes", name: "stringBytes", pkg: "encoding/json", typ: $funcType([sliceType$2], [$Int], false)}]; + floatEncoder.methods = [{prop: "encode", name: "encode", pkg: "encoding/json", typ: $funcType([ptrType$4, reflect.Value, $Bool], [], false)}]; + ptrType$17.methods = [{prop: "encode", name: "encode", pkg: "encoding/json", typ: $funcType([ptrType$4, reflect.Value, $Bool], [], false)}]; + ptrType$18.methods = [{prop: "encode", name: "encode", pkg: "encoding/json", typ: $funcType([ptrType$4, reflect.Value, $Bool], [], false)}]; + ptrType$19.methods = [{prop: "encode", name: "encode", pkg: "encoding/json", typ: $funcType([ptrType$4, reflect.Value, $Bool], [], false)}]; + ptrType$20.methods = [{prop: "encode", name: "encode", pkg: "encoding/json", typ: $funcType([ptrType$4, reflect.Value, $Bool], [], false)}]; + ptrType$21.methods = [{prop: "encode", name: "encode", pkg: "encoding/json", typ: $funcType([ptrType$4, reflect.Value, $Bool], [], false)}]; + ptrType$22.methods = [{prop: "encode", name: "encode", pkg: "encoding/json", typ: $funcType([ptrType$4, reflect.Value, $Bool], [], false)}]; + stringValues.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)}, {prop: "get", name: "get", pkg: "encoding/json", typ: $funcType([$Int], [$String], false)}]; + byName.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)}]; + 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$8.methods = [{prop: "Error", name: "Error", pkg: "", typ: $funcType([], [$String], false)}]; + ptrType$23.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)}, {prop: "undo", name: "undo", pkg: "encoding/json", typ: $funcType([$Int], [], false)}]; + tagOptions.methods = [{prop: "Contains", name: "Contains", pkg: "", typ: $funcType([$String], [$Bool], false)}]; + Marshaler.init([{prop: "MarshalJSON", name: "MarshalJSON", pkg: "", typ: $funcType([], [sliceType$2, $error], false)}]); + UnsupportedTypeError.init([{prop: "Type", name: "Type", pkg: "", typ: reflect.Type, tag: ""}]); + UnsupportedValueError.init([{prop: "Value", name: "Value", pkg: "", typ: reflect.Value, tag: ""}, {prop: "Str", name: "Str", pkg: "", typ: $String, tag: ""}]); + MarshalerError.init([{prop: "Type", name: "Type", pkg: "", typ: reflect.Type, tag: ""}, {prop: "Err", name: "Err", pkg: "", typ: $error, tag: ""}]); + encodeState.init([{prop: "Buffer", name: "", pkg: "", typ: bytes.Buffer, tag: ""}, {prop: "scratch", name: "scratch", pkg: "encoding/json", typ: arrayType$1, tag: ""}]); + encoderFunc.init([ptrType$4, reflect.Value, $Bool], [], false); + structEncoder.init([{prop: "fields", name: "fields", pkg: "encoding/json", typ: sliceType$1, tag: ""}, {prop: "fieldEncs", name: "fieldEncs", pkg: "encoding/json", typ: sliceType$4, tag: ""}]); + mapEncoder.init([{prop: "elemEnc", name: "elemEnc", pkg: "encoding/json", typ: encoderFunc, tag: ""}]); + sliceEncoder.init([{prop: "arrayEnc", name: "arrayEnc", pkg: "encoding/json", typ: encoderFunc, tag: ""}]); + arrayEncoder.init([{prop: "elemEnc", name: "elemEnc", pkg: "encoding/json", typ: encoderFunc, tag: ""}]); + ptrEncoder.init([{prop: "elemEnc", name: "elemEnc", pkg: "encoding/json", typ: encoderFunc, tag: ""}]); + condAddrEncoder.init([{prop: "canAddrEnc", name: "canAddrEnc", pkg: "encoding/json", typ: encoderFunc, tag: ""}, {prop: "elseEnc", name: "elseEnc", pkg: "encoding/json", typ: encoderFunc, tag: ""}]); + stringValues.init(reflect.Value); + field.init([{prop: "name", name: "name", pkg: "encoding/json", typ: $String, tag: ""}, {prop: "nameBytes", name: "nameBytes", pkg: "encoding/json", typ: sliceType$2, tag: ""}, {prop: "equalFold", name: "equalFold", pkg: "encoding/json", typ: funcType, tag: ""}, {prop: "tag", name: "tag", pkg: "encoding/json", typ: $Bool, tag: ""}, {prop: "index", name: "index", pkg: "encoding/json", typ: sliceType$3, tag: ""}, {prop: "typ", name: "typ", pkg: "encoding/json", typ: reflect.Type, tag: ""}, {prop: "omitEmpty", name: "omitEmpty", pkg: "encoding/json", typ: $Bool, tag: ""}, {prop: "quoted", name: "quoted", pkg: "encoding/json", typ: $Bool, tag: ""}]); + byName.init(field); + byIndex.init(field); + SyntaxError.init([{prop: "msg", name: "msg", pkg: "encoding/json", typ: $String, tag: ""}, {prop: "Offset", name: "Offset", pkg: "", typ: $Int64, tag: ""}]); + scanner.init([{prop: "step", name: "step", pkg: "encoding/json", typ: funcType$1, tag: ""}, {prop: "endTop", name: "endTop", pkg: "encoding/json", typ: $Bool, tag: ""}, {prop: "parseState", name: "parseState", pkg: "encoding/json", typ: sliceType$3, tag: ""}, {prop: "err", name: "err", pkg: "encoding/json", typ: $error, tag: ""}, {prop: "redo", name: "redo", pkg: "encoding/json", typ: $Bool, tag: ""}, {prop: "redoCode", name: "redoCode", pkg: "encoding/json", typ: $Int, tag: ""}, {prop: "redoState", name: "redoState", pkg: "encoding/json", typ: funcType$1, tag: ""}, {prop: "bytes", name: "bytes", pkg: "encoding/json", 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 = runtime.$init(); /* */ $s = 10; case 10: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = sort.$init(); /* */ $s = 11; case 11: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = strconv.$init(); /* */ $s = 12; case 12: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = strings.$init(); /* */ $s = 13; case 13: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = testing.$init(); /* */ $s = 14; case 14: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = unicode.$init(); /* */ $s = 15; case 15: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = utf16.$init(); /* */ $s = 16; case 16: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + $r = utf8.$init(); /* */ $s = 17; case 17: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + encoderCache = new structType.ptr(new nosync.RWMutex.ptr(false, 0), false); + fieldCache = new structType$1.ptr(new nosync.RWMutex.ptr(false, 0), false); + errPhase = errors.New("JSON decoder out of sync - data changing underfoot?"); + numberType = reflect.TypeOf(new Number("")); + hex = "0123456789abcdef"; + _r = reflect.TypeOf($newDataPointer($ifaceNil, ptrType)).Elem(); /* */ $s = 18; case 18: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + marshalerType = _r; + _r$1 = reflect.TypeOf($newDataPointer($ifaceNil, ptrType$1)).Elem(); /* */ $s = 19; case 19: if($c) { $c = false; _r$1 = _r$1.$blk(); } if (_r$1 && _r$1.$blk !== undefined) { break s; } + textMarshalerType = _r$1; + float32Encoder = $methodVal(new floatEncoder(32), "encode"); + float64Encoder = $methodVal(new floatEncoder(64), "encode"); + /* */ } return; } if ($f === undefined) { $f = { $blk: $init }; } $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.$init = $init; + return $pkg; +})(); +$packages["github.com/ZiRo-/cuckgo/miner_js"] = (function() { + var $pkg = {}, $init, sha256, base64, json, js, Cuckoo, Edge, CuckooSolve, CuckooJSON, arrayType, arrayType$1, arrayType$2, sliceType, sliceType$1, ptrType, sliceType$2, sliceType$3, ptrType$1, sliceType$4, funcType, mapType, ptrType$3, mapType$1, sh, u8, u8to64, NewCuckoo, NewCuckooSHA, siphash24_js, NewCuckooSolve, contains, worker, mine_cuckoo, formatProof, main, EncodeCuckooJSON; + sha256 = $packages["crypto/sha256"]; + base64 = $packages["encoding/base64"]; + json = $packages["encoding/json"]; + js = $packages["github.com/gopherjs/gopherjs/js"]; + Cuckoo = $pkg.Cuckoo = $newType(0, $kindStruct, "main.Cuckoo", "Cuckoo", "github.com/ZiRo-/cuckgo/miner_js", function(v_, vh_, vl_, key_) { + this.$val = this; + if (arguments.length === 0) { + this.v = arrayType$1.zero(); + this.vh = arrayType$2.zero(); + this.vl = arrayType$2.zero(); + this.key = sliceType.nil; + return; + } + this.v = v_; + this.vh = vh_; + this.vl = vl_; + this.key = key_; + }); + Edge = $pkg.Edge = $newType(0, $kindStruct, "main.Edge", "Edge", "github.com/ZiRo-/cuckgo/miner_js", function(U_, V_) { + this.$val = this; + if (arguments.length === 0) { + this.U = new $Uint64(0, 0); + this.V = new $Uint64(0, 0); + return; + } + this.U = U_; + this.V = V_; + }); + CuckooSolve = $pkg.CuckooSolve = $newType(0, $kindStruct, "main.CuckooSolve", "CuckooSolve", "github.com/ZiRo-/cuckgo/miner_js", function(graph_, easiness_, cuckoo_, sols_, nsols_, nthreads_) { + this.$val = this; + if (arguments.length === 0) { + this.graph = ptrType.nil; + this.easiness = 0; + this.cuckoo = sliceType$2.nil; + this.sols = sliceType$3.nil; + this.nsols = 0; + this.nthreads = 0; + return; + } + this.graph = graph_; + this.easiness = easiness_; + this.cuckoo = cuckoo_; + this.sols = sols_; + this.nsols = nsols_; + this.nthreads = nthreads_; + }); + CuckooJSON = $pkg.CuckooJSON = $newType(0, $kindStruct, "main.CuckooJSON", "CuckooJSON", "github.com/ZiRo-/cuckgo/miner_js", function(Parameter_, InputData_, Cycle_) { + this.$val = this; + if (arguments.length === 0) { + this.Parameter = false; + this.InputData = sliceType.nil; + this.Cycle = sliceType$1.nil; + return; + } + this.Parameter = Parameter_; + this.InputData = InputData_; + this.Cycle = Cycle_; + }); + arrayType = $arrayType($Uint8, 32); + arrayType$1 = $arrayType($Uint64, 4); + arrayType$2 = $arrayType($Uint32, 4); + sliceType = $sliceType($Uint8); + sliceType$1 = $sliceType($Uint64); + ptrType = $ptrType(Cuckoo); + sliceType$2 = $sliceType($Int); + sliceType$3 = $sliceType(sliceType$2); + ptrType$1 = $ptrType(Edge); + sliceType$4 = $sliceType($String); + funcType = $funcType([sliceType, $Float64], [sliceType$4], false); + mapType = $mapType($String, $emptyInterface); + ptrType$3 = $ptrType(CuckooSolve); + mapType$1 = $mapType($String, $Uint64); + u8 = function(b) { + var $ptr, b, x; + return (x = new $Uint64(0, b), new $Uint64(x.$high & 0, (x.$low & 255) >>> 0)); + }; + u8to64 = function(p, i) { + var $ptr, i, p, 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$3, x$4, x$5, x$6, x$7, x$8, x$9; + p = $clone(p, arrayType); + return (x = (x$1 = (x$2 = (x$3 = (x$4 = (x$5 = (x$6 = u8(((i < 0 || i >= p.length) ? $throwRuntimeError("index out of range") : p[i])), x$7 = $shiftLeft64(u8((x$8 = i + 1 >> 0, ((x$8 < 0 || x$8 >= p.length) ? $throwRuntimeError("index out of range") : p[x$8]))), 8), new $Uint64(x$6.$high | x$7.$high, (x$6.$low | x$7.$low) >>> 0)), x$9 = $shiftLeft64(u8((x$10 = i + 2 >> 0, ((x$10 < 0 || x$10 >= p.length) ? $throwRuntimeError("index out of range") : p[x$10]))), 16), new $Uint64(x$5.$high | x$9.$high, (x$5.$low | x$9.$low) >>> 0)), x$11 = $shiftLeft64(u8((x$12 = i + 3 >> 0, ((x$12 < 0 || x$12 >= p.length) ? $throwRuntimeError("index out of range") : p[x$12]))), 24), new $Uint64(x$4.$high | x$11.$high, (x$4.$low | x$11.$low) >>> 0)), x$13 = $shiftLeft64(u8((x$14 = i + 4 >> 0, ((x$14 < 0 || x$14 >= p.length) ? $throwRuntimeError("index out of range") : p[x$14]))), 32), new $Uint64(x$3.$high | x$13.$high, (x$3.$low | x$13.$low) >>> 0)), x$15 = $shiftLeft64(u8((x$16 = i + 5 >> 0, ((x$16 < 0 || x$16 >= p.length) ? $throwRuntimeError("index out of range") : p[x$16]))), 40), new $Uint64(x$2.$high | x$15.$high, (x$2.$low | x$15.$low) >>> 0)), x$17 = $shiftLeft64(u8((x$18 = i + 6 >> 0, ((x$18 < 0 || x$18 >= p.length) ? $throwRuntimeError("index out of range") : p[x$18]))), 48), new $Uint64(x$1.$high | x$17.$high, (x$1.$low | x$17.$low) >>> 0)), x$19 = $shiftLeft64(u8((x$20 = i + 7 >> 0, ((x$20 < 0 || x$20 >= p.length) ? $throwRuntimeError("index out of range") : p[x$20]))), 56), new $Uint64(x.$high | x$19.$high, (x.$low | x$19.$low) >>> 0)); + }; + NewCuckoo = function(header) { + var $ptr, hdrkey, header; + hdrkey = $clone(sha256.Sum256(header), arrayType); + return NewCuckooSHA(hdrkey); + }; + $pkg.NewCuckoo = NewCuckoo; + NewCuckooSHA = function(hdrkey) { + var $ptr, _i, _ref, h, hdrkey, i, k0, k1, self, x, x$1; + hdrkey = $clone(hdrkey, arrayType); + self = new Cuckoo.ptr(arrayType$1.zero(), arrayType$2.zero(), arrayType$2.zero(), sliceType.nil); + k0 = u8to64(hdrkey, 0); + k1 = u8to64(hdrkey, 8); + self.v[0] = new $Uint64(k0.$high ^ 1936682341, (k0.$low ^ 1886610805) >>> 0); + self.v[1] = new $Uint64(k1.$high ^ 1685025377, (k1.$low ^ 1852075885) >>> 0); + self.v[2] = new $Uint64(k0.$high ^ 1819895653, (k0.$low ^ 1852142177) >>> 0); + self.v[3] = new $Uint64(k1.$high ^ 1952801890, (k1.$low ^ 2037671283) >>> 0); + self.key = new sliceType(hdrkey); + _ref = self.v; + _i = 0; + while (true) { + if (!(_i < 4)) { break; } + i = _i; + h = ((_i < 0 || _i >= _ref.length) ? $throwRuntimeError("index out of range") : _ref[_i]); + (x = self.vl, ((i < 0 || i >= x.length) ? $throwRuntimeError("index out of range") : x[i] = (new $Uint64(h.$high & 0, (h.$low & 4294967295) >>> 0).$low >>> 0))); + (x$1 = self.vh, ((i < 0 || i >= x$1.length) ? $throwRuntimeError("index out of range") : x$1[i] = ($shiftRightUint64((new $Uint64(h.$high & 4294967295, (h.$low & 0) >>> 0)), 32).$low >>> 0))); + _i++; + } + return self; + }; + $pkg.NewCuckooSHA = NewCuckooSHA; + Edge.ptr.prototype.HashCode = function() { + var $ptr, self; + self = this; + return ((self.U.$low >> 0) ^ (self.V.$low >> 0)) >> 0; + }; + Edge.prototype.HashCode = function() { return this.$val.HashCode(); }; + Cuckoo.ptr.prototype.Sipedge = function(nonce) { + var $ptr, nonce, self; + self = this; + return new Edge.ptr(self.Sipnode(nonce, 0), self.Sipnode(nonce, 1)); + }; + Cuckoo.prototype.Sipedge = function(nonce) { return this.$val.Sipedge(nonce); }; + Cuckoo.ptr.prototype.siphash24 = function(nonce) { + var $ptr, nonce, self; + self = this; + return siphash24_js(self.vh, self.vl, nonce); + }; + Cuckoo.prototype.siphash24 = function(nonce) { return this.$val.siphash24(nonce); }; + siphash24_js = function(vh, vl, nonce) { + var $ptr, arr, high, low, nonce, vh, vl, x; + vl = $clone(vl, arrayType$2); + vh = $clone(vh, arrayType$2); + arr = sh.hash(vh[0], vl[0], vh[1], vl[1], vh[2], vl[2], vh[3], vl[3], 0, $externalize(nonce, $Uint64)); + high = $internalize(arr[0], $Uint64); + low = $internalize(arr[1], $Uint64); + return (x = $shiftLeft64(high, 32), new $Uint64(x.$high | low.$high, (x.$low | low.$low) >>> 0)); + }; + Cuckoo.ptr.prototype.Sipnode = function(nonce, uorv) { + var $ptr, nonce, self, uorv, x, x$1, x$2; + self = this; + return (x = self.siphash24((x$1 = $mul64(new $Uint64(0, 2), nonce), x$2 = new $Uint64(0, uorv), new $Uint64(x$1.$high + x$2.$high, x$1.$low + x$2.$low))), new $Uint64(x.$high & 0, (x.$low & 524287) >>> 0)); + }; + Cuckoo.prototype.Sipnode = function(nonce, uorv) { return this.$val.Sipnode(nonce, uorv); }; + Cuckoo.ptr.prototype.Verify = function(nonces, easiness) { + var $ptr, easiness, i, j, k, k$1, loop, n, nonces, self, us, vs, x, x$1, x$10, x$11, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9; + self = this; + us = $makeSlice(sliceType$1, 42); + vs = $makeSlice(sliceType$1, 42); + i = 0; + n = new $Uint64(0, 0); + n = new $Uint64(0, 0); + while (true) { + if (!((n.$high < 0 || (n.$high === 0 && n.$low < 42)))) { break; } + if ((x = (($flatten64(n) < 0 || $flatten64(n) >= nonces.$length) ? $throwRuntimeError("index out of range") : nonces.$array[nonces.$offset + $flatten64(n)]), (x.$high > easiness.$high || (x.$high === easiness.$high && x.$low >= easiness.$low))) || (!((n.$high === 0 && n.$low === 0)) && (x$1 = (($flatten64(n) < 0 || $flatten64(n) >= nonces.$length) ? $throwRuntimeError("index out of range") : nonces.$array[nonces.$offset + $flatten64(n)]), x$2 = (x$3 = new $Uint64(n.$high - 0, n.$low - 1), (($flatten64(x$3) < 0 || $flatten64(x$3) >= nonces.$length) ? $throwRuntimeError("index out of range") : nonces.$array[nonces.$offset + $flatten64(x$3)])), (x$1.$high < x$2.$high || (x$1.$high === x$2.$high && x$1.$low <= x$2.$low))))) { + return false; + } + (($flatten64(n) < 0 || $flatten64(n) >= us.$length) ? $throwRuntimeError("index out of range") : us.$array[us.$offset + $flatten64(n)] = self.Sipnode((($flatten64(n) < 0 || $flatten64(n) >= nonces.$length) ? $throwRuntimeError("index out of range") : nonces.$array[nonces.$offset + $flatten64(n)]), 0)); + (($flatten64(n) < 0 || $flatten64(n) >= vs.$length) ? $throwRuntimeError("index out of range") : vs.$array[vs.$offset + $flatten64(n)] = self.Sipnode((($flatten64(n) < 0 || $flatten64(n) >= nonces.$length) ? $throwRuntimeError("index out of range") : nonces.$array[nonces.$offset + $flatten64(n)]), 1)); + n = (x$4 = new $Uint64(0, 1), new $Uint64(n.$high + x$4.$high, n.$low + x$4.$low)); + } + loop = true; + while (true) { + if (!(loop)) { break; } + j = i; + k = 0; + while (true) { + if (!((x$5 = new $Uint64(0, k), (x$5.$high < 0 || (x$5.$high === 0 && x$5.$low < 42))))) { break; } + if (!((k === i)) && (x$6 = ((k < 0 || k >= vs.$length) ? $throwRuntimeError("index out of range") : vs.$array[vs.$offset + k]), x$7 = ((i < 0 || i >= vs.$length) ? $throwRuntimeError("index out of range") : vs.$array[vs.$offset + i]), (x$6.$high === x$7.$high && x$6.$low === x$7.$low))) { + if (!((j === i))) { + return false; + } + j = k; + } + k = k + (1) >> 0; + } + if (j === i) { + return false; + } + i = j; + k$1 = 0; + while (true) { + if (!((x$8 = new $Uint64(0, k$1), (x$8.$high < 0 || (x$8.$high === 0 && x$8.$low < 42))))) { break; } + if (!((k$1 === j)) && (x$9 = ((k$1 < 0 || k$1 >= us.$length) ? $throwRuntimeError("index out of range") : us.$array[us.$offset + k$1]), x$10 = ((j < 0 || j >= us.$length) ? $throwRuntimeError("index out of range") : us.$array[us.$offset + j]), (x$9.$high === x$10.$high && x$9.$low === x$10.$low))) { + if (!((i === j))) { + return false; + } + i = k$1; + } + k$1 = k$1 + (1) >> 0; + } + if (i === j) { + return false; + } + n = (x$11 = new $Uint64(0, 2), new $Uint64(n.$high - x$11.$high, n.$low - x$11.$low)); + loop = !((i === 0)); + } + return (n.$high === 0 && n.$low === 0); + }; + Cuckoo.prototype.Verify = function(nonces, easiness) { return this.$val.Verify(nonces, easiness); }; + NewCuckooSolve = function(hdr, en, ms, nt) { + var $ptr, _i, _ref, en, hdr, i, ms, nt, self, x; + self = new CuckooSolve.ptr(NewCuckoo(hdr), en, $makeSlice(sliceType$2, 1048577), $makeSlice(sliceType$3, ($imul(2, ms))), 0, 1); + _ref = self.sols; + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + (x = self.sols, ((i < 0 || i >= x.$length) ? $throwRuntimeError("index out of range") : x.$array[x.$offset + i] = $makeSlice(sliceType$2, 42))); + _i++; + } + return self; + }; + $pkg.NewCuckooSolve = NewCuckooSolve; + CuckooSolve.ptr.prototype.path = function(u, us) { + var $ptr, nu, self, u, us, x, x$1; + self = this; + nu = 0; + nu = 0; + while (true) { + if (!(!((u === 0)))) { break; } + nu = nu + (1) >> 0; + if (nu >= 4096) { + while (true) { + if (!(!((nu === 0)) && !(((x = nu - 1 >> 0, ((x < 0 || x >= us.$length) ? $throwRuntimeError("index out of range") : us.$array[us.$offset + x])) === u)))) { break; } + nu = nu - (1) >> 0; + } + if (nu < 0) { + } else { + } + return -1; + } + ((nu < 0 || nu >= us.$length) ? $throwRuntimeError("index out of range") : us.$array[us.$offset + nu] = u); + u = (x$1 = self.cuckoo, ((u < 0 || u >= x$1.$length) ? $throwRuntimeError("index out of range") : x$1.$array[x$1.$offset + u])); + } + return nu; + }; + CuckooSolve.prototype.path = function(u, us) { return this.$val.path(u, us); }; + CuckooSolve.ptr.prototype.solution = function(us, nu, vs, nv) { + var $ptr, _entry, _entry$1, _key, _key$1, _key$2, _tuple, _tuple$1, _tuple$2, cycle, e, edg, edg$1, edg$2, has, has$1, has$2, key, n, nonce, nu, nv, self, us, vs, x, x$1, x$10, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9; + self = this; + cycle = {}; + n = 0; + edg = new Edge.ptr(new $Uint64(0, (0 >= us.$length ? $throwRuntimeError("index out of range") : us.$array[us.$offset + 0])), (x = new $Uint64(0, (0 >= vs.$length ? $throwRuntimeError("index out of range") : vs.$array[vs.$offset + 0])), new $Uint64(x.$high - 0, x.$low - 524288))); + _key = edg.HashCode(); (cycle || $throwRuntimeError("assignment to entry in nil map"))[$Int.keyFor(_key)] = { k: _key, v: edg }; + while (true) { + if (!(!((nu === 0)))) { break; } + nu = nu - (1) >> 0; + edg$1 = new Edge.ptr(new $Uint64(0, (x$1 = (((nu + 1 >> 0)) & ~1) >> 0, ((x$1 < 0 || x$1 >= us.$length) ? $throwRuntimeError("index out of range") : us.$array[us.$offset + x$1]))), (x$2 = new $Uint64(0, (x$3 = nu | 1, ((x$3 < 0 || x$3 >= us.$length) ? $throwRuntimeError("index out of range") : us.$array[us.$offset + x$3]))), new $Uint64(x$2.$high - 0, x$2.$low - 524288))); + _tuple = (_entry = cycle[$Int.keyFor(edg$1.HashCode())], _entry !== undefined ? [_entry.v, true] : [ptrType$1.nil, false]); + has = _tuple[1]; + if (!has) { + _key$1 = edg$1.HashCode(); (cycle || $throwRuntimeError("assignment to entry in nil map"))[$Int.keyFor(_key$1)] = { k: _key$1, v: edg$1 }; + } + } + while (true) { + if (!(!((nv === 0)))) { break; } + nv = nv - (1) >> 0; + edg$2 = new Edge.ptr(new $Uint64(0, (x$4 = nv | 1, ((x$4 < 0 || x$4 >= vs.$length) ? $throwRuntimeError("index out of range") : vs.$array[vs.$offset + x$4]))), (x$5 = new $Uint64(0, (x$6 = (((nv + 1 >> 0)) & ~1) >> 0, ((x$6 < 0 || x$6 >= vs.$length) ? $throwRuntimeError("index out of range") : vs.$array[vs.$offset + x$6]))), new $Uint64(x$5.$high - 0, x$5.$low - 524288))); + _tuple$1 = (_entry$1 = cycle[$Int.keyFor(edg$2.HashCode())], _entry$1 !== undefined ? [_entry$1.v, true] : [ptrType$1.nil, false]); + has$1 = _tuple$1[1]; + if (!has$1) { + _key$2 = edg$2.HashCode(); (cycle || $throwRuntimeError("assignment to entry in nil map"))[$Int.keyFor(_key$2)] = { k: _key$2, v: edg$2 }; + } + } + n = 0; + nonce = 0; + while (true) { + if (!(nonce < self.easiness)) { break; } + e = self.graph.Sipedge(new $Uint64(0, nonce)); + _tuple$2 = contains(cycle, e); + has$2 = _tuple$2[0]; + key = _tuple$2[1]; + if (has$2) { + (x$7 = (x$8 = self.sols, x$9 = self.nsols, ((x$9 < 0 || x$9 >= x$8.$length) ? $throwRuntimeError("index out of range") : x$8.$array[x$8.$offset + x$9])), ((n < 0 || n >= x$7.$length) ? $throwRuntimeError("index out of range") : x$7.$array[x$7.$offset + n] = nonce)); + n = n + (1) >> 0; + delete cycle[$Int.keyFor(key)]; + } + nonce = nonce + (1) >> 0; + } + if ((x$10 = new $Uint64(0, n), (x$10.$high === 0 && x$10.$low === 42))) { + self.nsols = self.nsols + (1) >> 0; + } else { + } + }; + CuckooSolve.prototype.solution = function(us, nu, vs, nv) { return this.$val.solution(us, nu, vs, nv); }; + contains = function(m, e) { + var $ptr, _entry, _i, _keys, _ref, e, h, k, m, v, x, x$1, x$2, x$3; + h = e.HashCode(); + _ref = m; + _i = 0; + _keys = $keys(_ref); + while (true) { + if (!(_i < _keys.length)) { break; } + _entry = _ref[_keys[_i]]; + if (_entry === undefined) { + _i++; + continue; + } + k = _entry.k; + v = _entry.v; + if ((k === h) && (x = v.U, x$1 = e.U, (x.$high === x$1.$high && x.$low === x$1.$low)) && (x$2 = v.V, x$3 = e.V, (x$2.$high === x$3.$high && x$2.$low === x$3.$low))) { + return [true, k]; + } + _i++; + } + return [false, 0]; + }; + worker = function(id, solve) { + var $ptr, cuck, id, length, min, nonce, nu, nv, solve, u, us, v, vs, x, x$1, x$2, x$3, x$4, x$5, x$6, x$7, x$8, x$9; + cuck = solve.cuckoo; + us = $makeSlice(sliceType$2, 4096); + vs = $makeSlice(sliceType$2, 4096); + nonce = id; + while (true) { + if (!(nonce < solve.easiness)) { break; } + (0 >= us.$length ? $throwRuntimeError("index out of range") : us.$array[us.$offset + 0] = (solve.graph.Sipnode(new $Uint64(0, nonce), 0).$low >> 0)); + u = (x = (0 >= us.$length ? $throwRuntimeError("index out of range") : us.$array[us.$offset + 0]), ((x < 0 || x >= cuck.$length) ? $throwRuntimeError("index out of range") : cuck.$array[cuck.$offset + x])); + (0 >= vs.$length ? $throwRuntimeError("index out of range") : vs.$array[vs.$offset + 0] = ((x$1 = solve.graph.Sipnode(new $Uint64(0, nonce), 1), new $Uint64(0 + x$1.$high, 524288 + x$1.$low)).$low >> 0)); + v = (x$2 = (0 >= vs.$length ? $throwRuntimeError("index out of range") : vs.$array[vs.$offset + 0]), ((x$2 < 0 || x$2 >= cuck.$length) ? $throwRuntimeError("index out of range") : cuck.$array[cuck.$offset + x$2])); + if ((u === (0 >= vs.$length ? $throwRuntimeError("index out of range") : vs.$array[vs.$offset + 0])) || (v === (0 >= us.$length ? $throwRuntimeError("index out of range") : us.$array[us.$offset + 0]))) { + nonce = nonce + (solve.nthreads) >> 0; + continue; + } + nu = solve.path(u, us); + nv = solve.path(v, vs); + if ((nu === -1) || (nv === -1)) { + return; + } + if (((nu < 0 || nu >= us.$length) ? $throwRuntimeError("index out of range") : us.$array[us.$offset + nu]) === ((nv < 0 || nv >= vs.$length) ? $throwRuntimeError("index out of range") : vs.$array[vs.$offset + nv])) { + min = 0; + if (nu < nv) { + min = nu; + } else { + min = nv; + } + nu = nu - (min) >> 0; + nv = nv - (min) >> 0; + while (true) { + if (!(!((((nu < 0 || nu >= us.$length) ? $throwRuntimeError("index out of range") : us.$array[us.$offset + nu]) === ((nv < 0 || nv >= vs.$length) ? $throwRuntimeError("index out of range") : vs.$array[vs.$offset + nv]))))) { break; } + nu = nu + (1) >> 0; + nv = nv + (1) >> 0; + } + length = (nu + nv >> 0) + 1 >> 0; + if ((x$3 = new $Uint64(0, length), (x$3.$high === 0 && x$3.$low === 42)) && solve.nsols < solve.sols.$length) { + solve.solution(us, nu, vs, nv); + } + nonce = nonce + (solve.nthreads) >> 0; + continue; + } + if (nu < nv) { + while (true) { + if (!(!((nu === 0)))) { break; } + nu = nu - (1) >> 0; + (x$4 = (x$5 = nu + 1 >> 0, ((x$5 < 0 || x$5 >= us.$length) ? $throwRuntimeError("index out of range") : us.$array[us.$offset + x$5])), ((x$4 < 0 || x$4 >= cuck.$length) ? $throwRuntimeError("index out of range") : cuck.$array[cuck.$offset + x$4] = ((nu < 0 || nu >= us.$length) ? $throwRuntimeError("index out of range") : us.$array[us.$offset + nu]))); + } + (x$6 = (0 >= us.$length ? $throwRuntimeError("index out of range") : us.$array[us.$offset + 0]), ((x$6 < 0 || x$6 >= cuck.$length) ? $throwRuntimeError("index out of range") : cuck.$array[cuck.$offset + x$6] = (0 >= vs.$length ? $throwRuntimeError("index out of range") : vs.$array[vs.$offset + 0]))); + } else { + while (true) { + if (!(!((nv === 0)))) { break; } + nv = nv - (1) >> 0; + (x$7 = (x$8 = nv + 1 >> 0, ((x$8 < 0 || x$8 >= vs.$length) ? $throwRuntimeError("index out of range") : vs.$array[vs.$offset + x$8])), ((x$7 < 0 || x$7 >= cuck.$length) ? $throwRuntimeError("index out of range") : cuck.$array[cuck.$offset + x$7] = ((nv < 0 || nv >= vs.$length) ? $throwRuntimeError("index out of range") : vs.$array[vs.$offset + nv]))); + } + (x$9 = (0 >= vs.$length ? $throwRuntimeError("index out of range") : vs.$array[vs.$offset + 0]), ((x$9 < 0 || x$9 >= cuck.$length) ? $throwRuntimeError("index out of range") : cuck.$array[cuck.$offset + x$9] = (0 >= us.$length ? $throwRuntimeError("index out of range") : us.$array[us.$offset + 0]))); + } + nonce = nonce + (solve.nthreads) >> 0; + } + }; + mine_cuckoo = function(b, easipct) { + var $ptr, _r, _tuple, b, c, easipct, easy, json$1, res, solve, str, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; _tuple = $f._tuple; b = $f.b; c = $f.c; easipct = $f.easipct; easy = $f.easy; json$1 = $f.json$1; res = $f.res; solve = $f.solve; str = $f.str; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + easy = (easipct * 1.048576e+06 / 100 >> 0); + solve = NewCuckooSolve(b, easy, 8, 1); + worker(0, solve); + res = $makeSlice(sliceType$4, 2); + /* */ if (solve.nsols > 0) { $s = 1; continue; } + /* */ $s = 2; continue; + /* if (solve.nsols > 0) { */ case 1: + c = $clone(formatProof(solve, b), CuckooJSON); + _r = EncodeCuckooJSON(c); /* */ $s = 4; case 4: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + _tuple = _r; + json$1 = _tuple[0]; + str = base64.StdEncoding.EncodeToString(json$1); + (0 >= res.$length ? $throwRuntimeError("index out of range") : res.$array[res.$offset + 0] = "ok"); + (1 >= res.$length ? $throwRuntimeError("index out of range") : res.$array[res.$offset + 1] = str); + $s = 3; continue; + /* } else { */ case 2: + (0 >= res.$length ? $throwRuntimeError("index out of range") : res.$array[res.$offset + 0] = "D^:"); + /* } */ case 3: + return res; + /* */ } return; } if ($f === undefined) { $f = { $blk: mine_cuckoo }; } $f.$ptr = $ptr; $f._r = _r; $f._tuple = _tuple; $f.b = b; $f.c = c; $f.easipct = easipct; $f.easy = easy; $f.json$1 = json$1; $f.res = res; $f.solve = solve; $f.str = str; $f.$s = $s; $f.$r = $r; return $f; + }; + formatProof = function(solve, b) { + var $ptr, _i, _key, _ref, b, cycle, easy, i, m, n, sha, solve, x, x$1; + sha = $clone(sha256.Sum256(b), arrayType); + easy = new $Uint64(0, solve.easiness); + cycle = $makeSlice(sliceType$1, (x = solve.sols, (0 >= x.$length ? $throwRuntimeError("index out of range") : x.$array[x.$offset + 0])).$length); + m = {}; + _key = "easiness"; (m || $throwRuntimeError("assignment to entry in nil map"))[$String.keyFor(_key)] = { k: _key, v: easy }; + _ref = (x$1 = solve.sols, (0 >= x$1.$length ? $throwRuntimeError("index out of range") : x$1.$array[x$1.$offset + 0])); + _i = 0; + while (true) { + if (!(_i < _ref.$length)) { break; } + i = _i; + n = ((_i < 0 || _i >= _ref.$length) ? $throwRuntimeError("index out of range") : _ref.$array[_ref.$offset + _i]); + ((i < 0 || i >= cycle.$length) ? $throwRuntimeError("index out of range") : cycle.$array[cycle.$offset + i] = new $Uint64(0, n)); + _i++; + } + return new CuckooJSON.ptr(m, new sliceType(sha), cycle); + }; + main = function() { + var $ptr; + $global.cuckoo = $externalize($makeMap($String.keyFor, [{ k: "mine_cuckoo", v: new funcType(mine_cuckoo) }]), mapType); + }; + EncodeCuckooJSON = function(cuck) { + var $ptr, _r, cuck, $s, $r; + /* */ $s = 0; var $f, $c = false; if (this !== undefined && this.$blk !== undefined) { $f = this; $c = true; $ptr = $f.$ptr; _r = $f._r; cuck = $f.cuck; $s = $f.$s; $r = $f.$r; } s: while (true) { switch ($s) { case 0: + cuck = $clone(cuck, CuckooJSON); + _r = json.Marshal(new cuck.constructor.elem(cuck)); /* */ $s = 1; case 1: if($c) { $c = false; _r = _r.$blk(); } if (_r && _r.$blk !== undefined) { break s; } + /* */ $s = 2; case 2: + return _r; + /* */ } return; } if ($f === undefined) { $f = { $blk: EncodeCuckooJSON }; } $f.$ptr = $ptr; $f._r = _r; $f.cuck = cuck; $f.$s = $s; $f.$r = $r; return $f; + }; + $pkg.EncodeCuckooJSON = EncodeCuckooJSON; + ptrType.methods = [{prop: "Sipedge", name: "Sipedge", pkg: "", typ: $funcType([$Uint64], [ptrType$1], false)}, {prop: "siphash24", name: "siphash24", pkg: "github.com/ZiRo-/cuckgo/miner_js", typ: $funcType([$Uint64], [$Uint64], false)}, {prop: "Sipnode", name: "Sipnode", pkg: "", typ: $funcType([$Uint64, $Uint32], [$Uint64], false)}, {prop: "Verify", name: "Verify", pkg: "", typ: $funcType([sliceType$1, $Uint64], [$Bool], false)}]; + ptrType$1.methods = [{prop: "HashCode", name: "HashCode", pkg: "", typ: $funcType([], [$Int], false)}]; + ptrType$3.methods = [{prop: "path", name: "path", pkg: "github.com/ZiRo-/cuckgo/miner_js", typ: $funcType([$Int, sliceType$2], [$Int], false)}, {prop: "solution", name: "solution", pkg: "github.com/ZiRo-/cuckgo/miner_js", typ: $funcType([sliceType$2, $Int, sliceType$2, $Int], [], false)}]; + Cuckoo.init([{prop: "v", name: "v", pkg: "github.com/ZiRo-/cuckgo/miner_js", typ: arrayType$1, tag: ""}, {prop: "vh", name: "vh", pkg: "github.com/ZiRo-/cuckgo/miner_js", typ: arrayType$2, tag: ""}, {prop: "vl", name: "vl", pkg: "github.com/ZiRo-/cuckgo/miner_js", typ: arrayType$2, tag: ""}, {prop: "key", name: "key", pkg: "github.com/ZiRo-/cuckgo/miner_js", typ: sliceType, tag: ""}]); + Edge.init([{prop: "U", name: "U", pkg: "", typ: $Uint64, tag: ""}, {prop: "V", name: "V", pkg: "", typ: $Uint64, tag: ""}]); + CuckooSolve.init([{prop: "graph", name: "graph", pkg: "github.com/ZiRo-/cuckgo/miner_js", typ: ptrType, tag: ""}, {prop: "easiness", name: "easiness", pkg: "github.com/ZiRo-/cuckgo/miner_js", typ: $Int, tag: ""}, {prop: "cuckoo", name: "cuckoo", pkg: "github.com/ZiRo-/cuckgo/miner_js", typ: sliceType$2, tag: ""}, {prop: "sols", name: "sols", pkg: "github.com/ZiRo-/cuckgo/miner_js", typ: sliceType$3, tag: ""}, {prop: "nsols", name: "nsols", pkg: "github.com/ZiRo-/cuckgo/miner_js", typ: $Int, tag: ""}, {prop: "nthreads", name: "nthreads", pkg: "github.com/ZiRo-/cuckgo/miner_js", typ: $Int, tag: ""}]); + CuckooJSON.init([{prop: "Parameter", name: "Parameter", pkg: "", typ: mapType$1, tag: "json:\"parameters\""}, {prop: "InputData", name: "InputData", pkg: "", typ: sliceType, tag: "json:\"header\""}, {prop: "Cycle", name: "Cycle", pkg: "", typ: sliceType$1, tag: "json:\"cycle\""}]); + $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 = base64.$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 = js.$init(); /* */ $s = 4; case 4: if($c) { $c = false; $r = $r.$blk(); } if ($r && $r.$blk !== undefined) { break s; } + sh = $global.SipHash; + 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["github.com/ZiRo-/cuckgo/miner_js"]; +$packages["runtime"].$init(); +$go($mainPkg.$init, [], true); +$flushConsole(); + +}).call(this); +//# sourceMappingURL=miner_js.js.map diff --git a/contrib/backends/srndv2/src/github.com/ZiRo-/cuckgo/miner_js/miner_js.js.map b/contrib/backends/srndv2/src/github.com/ZiRo-/cuckgo/miner_js/miner_js.js.map new file mode 100644 index 0000000..cf1d578 --- /dev/null +++ b/contrib/backends/srndv2/src/github.com/ZiRo-/cuckgo/miner_js/miner_js.js.map @@ -0,0 +1 @@ +{"version":3,"file":"miner_js.js","sources":["/github.com/gopherjs/gopherjs/js/js.go","/github.com/gopherjs/gopherjs/compiler/natives/runtime/runtime.go","/runtime/error.go","/errors/errors.go","/github.com/gopherjs/gopherjs/compiler/natives/sync/atomic/atomic.go","/github.com/gopherjs/gopherjs/compiler/natives/sync/pool.go","/github.com/gopherjs/gopherjs/compiler/natives/sync/sync.go","/sync/mutex.go","/sync/once.go","/sync/pool.go","/sync/runtime.go","/sync/rwmutex.go","/github.com/gopherjs/gopherjs/compiler/natives/math/math.go","/math/pow10.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","/encoding/base64/base64.go","/github.com/gopherjs/gopherjs/compiler/natives/unicode/unicode.go","/unicode/digit.go","/unicode/graphic.go","/unicode/letter.go","/github.com/gopherjs/gopherjs/compiler/natives/bytes/bytes.go","/bytes/buffer.go","/bytes/bytes.go","/github.com/gopherjs/gopherjs/compiler/natives/syscall/syscall.go","/github.com/gopherjs/gopherjs/compiler/natives/syscall/syscall_unix.go","/syscall/env_unix.go","/syscall/str.go","/syscall/syscall.go","/syscall/syscall_linux.go","/syscall/syscall_unix.go","/syscall/zsyscall_linux_amd64.go","/github.com/gopherjs/gopherjs/nosync/mutex.go","/github.com/gopherjs/gopherjs/nosync/once.go","/github.com/gopherjs/gopherjs/compiler/natives/strings/strings.go","/strings/strings.go","/github.com/gopherjs/gopherjs/compiler/natives/time/time.go","/time/format.go","/time/time.go","/time/zoneinfo.go","/github.com/gopherjs/gopherjs/compiler/natives/os/os.go","/os/dir_unix.go","/os/doc.go","/os/error.go","/os/error_unix.go","/os/file.go","/os/file_posix.go","/os/file_unix.go","/os/proc.go","/os/stat_linux.go","/os/types.go","/os/types_unix.go","/github.com/gopherjs/gopherjs/compiler/natives/reflect/reflect.go","/reflect/type.go","/reflect/value.go","/fmt/format.go","/fmt/print.go","/fmt/scan.go","/sort/search.go","/sort/sort.go","/flag/flag.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","/github.com/ZiRo-/cuckgo/miner_js/cuckoo.go","/github.com/ZiRo-/cuckgo/miner_js/miner-js.go","/github.com/ZiRo-/cuckgo/miner_js/verify-json.go"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BO;AAAqC;A;;;;AAGrC;AAAgD;A;;;;AAGhD;AAAgC;A;;;;AAGhC;AAA0B;A;;;;AAG1B;AAAkC;A;;;;AAGlC;AAAgD;A;;;;AAGhD;AAA4D;A;;;;AAG5D;AAAiD;A;;;;AAGjD;AAA8C;A;;;;AAG9C;AAAyB;A;;;;AAGzB;AAA6B;A;;;;AAG7B;AAAuB;A;;;;AAGvB;AAA2B;A;;;;AAG3B;AAA6B;A;;;;AAG7B;AAA6B;A;;;;AAG7B;AAAqC;A;;;;AAGrC;AAA8B;A;;;;AAQ9B;AACL;A;;;;AAIK;AACL;A;;;;AAwEA;A;;;;;;;;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC/IA;AACA;AACA;AACA;;AACC;A;AAGG;AACJ;A;;;AAKA;A;AAEC;A;AAED;A;AAEC;A;AAED;A;;;;AAwBA;AACA;A;;;;AAIA;A;;;;A;;;;A;;;;AC7CK;AACL;A;AAEC;A;A;AAGA;A;A;AAGA;A;AAGD;A;;;;AAOK;A;;;;AAEA;AACL;A;;;;;;;;;A;A;A;;;;;;;;;;;;;;;;;;;ACxCA;A;;;;AAQK;AACL;A;;;;;;;;;;;;;;;;A;;;;A;;;;A;;;;A;;;;A;;;;A;;;;A;;;;;;;;;;;;;;;A;AC8BC;AACA;A;AAED;A;;;;AA4CA;AACA;AACA;A;;;;AAoCA;A;;;;AAwBA;A;;;;;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;A;;;;AC/IK;AACL;;A;AACC;;A;AACC;;;A;AAED;A;AAED;AACA;AACA;A;;;;;AAGK;A;AAEJ;A;AAED;A;;;;A;;;;ACvBA;;A;AACC;AACA;AACA;;A;A;A;;;;;A;AAQD;A;AAEC;A;AAGD;AACA;AACA;A;AAEC;A;A;A;;;;AAOD;A;;;;ACOK;A;A;AAIH;A;AAED;A;AAGD;AACA;AACA;AACC;AACA;AACA;;A;A;A;AAOG;A;AAED;AACA;AACA;A;AAED;A;A;A;AAMC;A;AAED;A;AAED;;A;A;AAEE;A;AAED;AACA;AACA;A;A;A;AAKD;A;A;;;;;;AAUI;A;AAGJ;A;AAID;A;AAEC;A;AAGD;AACA;A;AAIE;A;AAGD;AACA;;A;AACC;AACA;A;AAED;A;A;;;;;;AC1FI;A;AAEJ;A;AAGD;AACA;AACA;;A;AACC;AACA;A;A;;;;;ACsJD;;;;;;AACC;AACI;;;AACH;AACA;AACA;;;;;AACC;A;;AAED;AANiC;A;AAQlC;AACA;A;;AAED;A;;;AASA;A;;;AAIA;A;;;ACtLI;AACJ;A;;;;;;;ACTK;A;AAGJ;A;AAED;;A;AAEC;A;A;AAGA;AACA;A;A;;;;;;AAQI;A;AAGJ;AACA;A;AAEE;AAAH;;A;A;AAEE;AACA;A;AAGD;;A;AAEC;A;A;A;AAID;A;A;;;;;;AAUI;A;AAGJ;A;AAGD;AAEA;AAEA;;A;AACC;A;A;AAGA;AACA;AACA;A;A;;;;;;AAUI;A;AAGJ;AACA;AACA;A;AAID;A;AAEC;AACA;A;AAGG;;;AACH;AADuB;A;AAIxB;A;AAEC;A;A;;;;;AAMI;AACL;A;;;;;AAKK;AAAuB;A;;;;;;AACvB;AAAuB;A;;;;;;;;;;;;;;;;;;;A;A;A;;A;A;A;;;;;;;;;;;;;;;;;;;;A;A;A;A;A;A;A;A;A;A;;;;;;;;;;;;;;;A;;;;;;;;;;;;;;;;A;AC5D3B;A;AAEA;A;A;;;;A;AAMA;A;A;AAGA;A;AAED;A;;;;;A;;A;;;;AA+DA;A;;;;AAgDA;AACA;AACA;AACA;A;;;AAIA;AACA;A;;;;AAIA;AACA;A;;;;AAIA;AACA;A;;;;AAIA;AACA;AACA;A;;;;AC/LA;AACA;AACI;;;AACH;AACA;AAF8B;A;A;;;;A;;;A;A;A;A;A;A;A;;;;;;;;;;;;;;;;;;;;;;ACsH/B;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;;;;A;AAoDC;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAED;A;;;;AAOO;A;AAEN;AACA;A;AAEA;AACA;AACA;A;AAEA;AAGA;AACA;AACA;AACA;A;AAHA;AACA;AACA;AACA;A;AAEA;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;;;;;;A;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;A;A;A;;;;;A;A;;;;;A;A;;;;;A;;;;A;AC3a5B;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;;;;AAGK;AACL;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;AAGD;AACA;AACA;A;;;;;;AAOK;AACD;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;;;A;;;;;A;AAGD;;;A;;;;;A;;;;;AClgBK;AACL;;;A;;;;;AAIA;A;;;AAIA;A;;;;;;AAYI;;;;A;AAGH;A;AAGD;AAEA;;;;A;AACC;AACA;A;A;A;A;AAQA;;;A;AACC;;A;AACC;AACA;A;AAED;AACA;A;A;AAEA;AACA;A;;AAEA;A;A;A;;AAID;AACA;A;A;A;A;AAOA;A;AAEA;A;AAEA;A;AAGD;AAEA;;AACK;AACJ;AAEA;;;;A;AACC;A;A;AAEA;A;A;AAEA;A;;AAEA;AACA;AACA;A;A;AAED;;A;AACC;AACA;AACA;A;AAGD;;A;AAEC;AACA;AACA;A;AAED;AAEA;AACA;;A;AAEC;AACA;AACA;A;AAED;AApCiB;A;A;;;;;AAyCnB;A;;;;;A;;;;;;;A;AAwBE;A;A;A;;;;;A;AASD;AACA;A;AAEC;A;AAEA;AACA;A;AAIG;AACJ;;;A;AAEC;AACA;A;;;;;A;AAGD;A;A;;;;;A;A;A;;;;;A;AAOA;A;AAEC;A;A;;;;;A;;;;AC3KI;AACL;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;;;AAKI;AACD;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;AAGA;;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;;;AAIK;A;A;AAKJ;;AACC;AACA;A;AAED;A;AAEA;;AACC;AACA;A;AAED;A;A;;;;A;AAOA;A;A;A;AAKC;A;AAED;A;AAGD;A;;;AAOK;A;AAEJ;A;A;AAGA;A;AAEA;A;A;;;;AAKI;A;AAEJ;A;AAED;AACA;A;;;;AAIK;A;AAEJ;A;AAIG;;;AACH;A;AAEC;AACA;AACA;A;AALuB;A;AAWzB;AACA;AACA;A;;;;AAKK;A;AAEJ;A;AAEG;AACJ;AACI;;;AACH;AADgC;A;AAGjC;;AACC;AADe;A;A;AAIf;A;AAED;A;;;;;;AC5RK;AACL;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;;;;;;AAOK;AACL;AACA;AACA;A;AAGC;AACA;A;;;;;A;AAGD;AAEA;A;AAEC;A;AAEA;A;AAED;A;;;;;AAKK;AACL;;;;A;A;;A;A;AAKC;AACA;A;A;AAGA;AACA;A;A;AAGA;AACA;A;A;AAGA;AACA;A;A;AAGA;AACA;A;A;AAGA;AACA;A;AAED;AACA;;;;AACA;A;;;;AAK2B;AAAtB;AACL;;;;AACA;;;;AAGA;AACA;AAGA;AACA;AAEA;AAEA;AACA;A;;;;;AAYK;AAGL;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;;;;;;AAgBK;AAUL;AACA;AAEA;;AACC;A;AAGC;A;AAEA;A;AAEA;A;A;AAKF;A;;;;;A;;;;;AAOA;;;AACA;AACA;AACA;A;;;AAMK;A;AAEJ;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;;;AAOK;A;AAEJ;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;;;AC9mBA;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;;;AAGsD;A;A;AAGrD;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;;;AA2CS;A;AAG9B;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;;;AAI+B;A;AAG9B;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;;;ACjbA;;AACA;A;;;;AAKA;A;;;;AAMA;;AACA;A;;;;AAMA;;AACA;A;;;;;;A;AAuBC;A;AAIG;AACJ;A;AAGC;A;A;A;AASC;;AACC;AACA;AACI;;;AACH;AACA;AACA;AACA;AAJkB;A;AAMnB;A;A;AAKF;AACA;;AACC;AACA;AACA;AACA;A;AAGD;AACA;A;AAES;A;AAET;AACA;AACA;;AACC;AACA;AACA;A;AAGD;AACA;A;AAIA;AACA;;AACC;AACA;AACA;AACA;A;AAGD;AACA;A;A;A;AAKA;AACA;A;A;AAIA;AACA;A;AAED;AACA;A;;;AC9HI;AACJ;AACA;AACI;;;AACH;AACA;A;AAEC;;;A;A;AAGA;AACA;AACA;AAT0B;;A;A;AAa1B;AACA;AAd0B;;A;A;A;AAmBzB;AAnByB;;A;A;AAuB1B;AACA;AAxB0B;;A;A;A;AA6B1B;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;AA1DI;;AAgE5B;AACA;A;;;AASA;A;;;;AAaA;A;;;;AA2BA;A;;;;AAMA;A;;;;AASA;A;;;;AAMA;A;;;;AAsBA;;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;;;;;;;AAmBO;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;A;;;;;A;AAIA;A;A;;;;;A;AAIA;A;A;A;;;;;A;A;;;;;A;A;A;;;;;A;A;A;;;;;A;A;A;A;A;;;;;A;AAqBE;;;A;A;;;;;A;A;A;AAOE;AACJ;AACA;;AACC;;;;;A;A;;;;;A;AAIA;A;AAEC;A;AAEA;AACA;A;A;A;;;;;A;A;A;;;;;A;;;;AAYE;;;A;AAEF;A;AAFsB;A;AAKxB;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;AC3ZC;A;AAED;A;;;;;A;A;A;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACjFA;AACA;A;;;AAyCK;A;AAEJ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;A;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;A;AAED;AACA;A;;;;AAKA;AACA;AACA;A;;;;AAKA;AACA;AACA;AACA;A;;;;AAGK;A;AAEJ;A;AAED;A;;;;AAGK;AAA6B;A;;;;;;AAE7B;AACL;AACA;A;AAEC;AACA;A;AAEC;AACA;A;AAED;A;A;AAGA;AACA;AACA;A;A;AAGA;A;AAED;A;;;;AAGK;AAEL;AACA;A;AAEC;A;AAED;A;;;;AAGK;AACL;AAEI;AACJ;A;AAEC;A;AAEA;A;AAID;AACI;;;AACH;AADwB;A;AAGzB;A;AAGC;A;AAGD;A;AAEC;A;AAGG;AACJ;;;;;;AACC;AACA;AACA;AACA;A;;AAGD;A;;;;AAKI;AACJ;AACA;AACA;A;;;;ACpGI;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;ACrFC;A;AAGD;AACA;AACA;AAEI;;;AACH;AADiC;A;AAG9B;;;AACH;AAD6B;A;AAG9B;A;;;;AAKK;AACL;AACA;A;;;;AA+BK;A;AAEJ;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;;;;AAMG;AACL;AACA;AACA;A;;;;;;;AAYK;A;A;;;;;A;AAML;;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;;;;;;AAKK;AAEL;;A;AACC;AACA;;;AACA;A;AAED;A;;;;;AASA;A;;;;AAKK;A;AAEJ;A;AAED;A;;;;AASK;AACL;A;;;;;;;AAMK;AACL;AAGA;;AACC;A;AAGD;;AAEK;AACJ;;;;AAEA;;;;;A;A;A;;;;;;;A;AAKE;;;;;;AACA;A;AAED;AAEA;AAEA;;AACC;A;A;A;A;A;;;;;;;A;A;A;;;;;;;A;A;A;;;;;;;A;AAoBC;AAEA;;AACC;A;A;A;AAKD;A;AAED;;;;;;AACA;A;AAED;A;A;;;;;;;A;A;;AAOD;A;A;AAGC;AAGA;AAGA;A;AAHA;AAGA;A;AAAA;A;AAED;AACA;A;A;;;;;;;A;;;;;;AAWI;AACL;;;AACA;A;;;;AAIK;AACL;AACA;;;AACA;A;;;;AAkHK;A;AAGJ;A;AAGD;A;;;;;;;;;;;A;A;A;A;A;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;A;AC1cC;A;AAED;AACA;AACA;;AACC;AACA;A;AAEC;A;AAEC;A;AAED;A;A;AAGA;A;AAEA;A;A;AAGF;A;;;A;ACjBC;A;AAED;A;;;;A;ACgFC;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;;;AAiBA;AACG;A;AACF;A;AAED;A;AAEC;A;AAED;A;;;AAoEA;A;;;;A;A;AAOE;A;AAED;A;AAED;A;;;;A;A;AAOE;A;AAED;A;AAED;A;;;;AAmEA;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC9VA;;;;;;A;AAEE;A;A;;AAGF;A;;;;ACiCK;AAA4B;A;;;;AAI5B;A;AAGJ;A;AAED;A;;;;AAKK;AAAuB;A;;;;AAIvB;AAAuB;A;;;;AAKvB;AACL;A;AAGC;A;AAGA;A;AAED;A;;;;AAMK;AAAqB;A;;;;AAKrB;AACL;A;AAGC;A;A;AAGI;A;AAEH;A;AAMA;AACA;A;AAGA;AACA;A;AAED;AACA;A;AAED;AACA;A;;;;AAQK;A;AAEJ;A;AAED;AACA;A;;;;;;AAMK;AACL;AACA;A;;;;;A;;;;;;AAOK;AACL;AACA;A;;;;;A;;;;;;;AAcK;AACL;A;AAGC;A;AAED;AACI;A;AAEF;A;AAIC;A;AAED;AACA;AACA;A;AAED;;;;AACA;AACA;A;AAEC;A;A;A;;;;;A;A;A;;;;;A;;;;;;AAaF;;A;AAEE;A;A;AAGF;A;;;;;;;AAOK;AACL;AACA;;A;AACC;AACA;;;;A;AAEC;A;AAED;AACA;A;A;;;;;A;A;A;;;;;A;A;AAWD;AACA;A;;;;;AAOK;AACL;AACA;AACA;AACA;A;;;;;;AAOK;A;AAEJ;A;;;;;A;AAGD;AACA;A;;;;;A;;;;;;AAQK;AACL;A;AAGC;A;AAEC;A;A;;;;;A;AAIF;AACA;A;AAEC;A;AAED;A;;;;AAOK;AACL;AACA;A;AAEC;A;AAED;AACA;A;AAEC;A;AAED;A;;;;;;AAKK;AACL;A;AAGC;A;;;;;A;AAGD;AACA;AACA;A;;;;;A;;;;;;;AASK;AACL;A;AAGC;A;;;;;;;A;AAGD;AACA;A;AAEC;A;;;;;;;A;AAGD;;;AACA;A;;;;;;;A;;;;AASK;A;AAEJ;A;AAED;A;AAEC;;AACA;A;AAED;A;;;;AAMK;A;AAEJ;A;AAED;A;AAEC;A;AAED;A;;;;;;AASK;AACL;;;AAGA;AACA;A;;;;;;AAIK;AACL;AACA;A;AAEC;AACA;A;AAED;AACA;AACA;A;;;;;A;;;;;;AAUK;AACL;;;A;;;;;A;;;;AC0QA;;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;;;;;;;A;A;A;A;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC1rBA;;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;;;A;;;AAUD;;;;;;A;AAEE;A;A;;AAGF;A;;;AC9CA;A;AAEC;A;AAED;AACA;AACA;AACI;;;AACH;AACA;AAFiC;A;AAIlC;A;;;;AAeA;;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;;;;AAwBD;AACA;;;;;;A;AAEE;A;AAED;A;;AAED;AACA;A;;;;AC7EA;AACA;;;;;;AACK;;;A;AAEF;AACG;;A;AACF;A;AAMA;A;AAED;A;AAZsB;A;A;;A;;;;;;AAiCzB;A;A;;;;;A;AAKA;AACA;AAEA;;;A;A;;;;;A;AAIA;AACI;;;A;A;;;;;A;AAAoB;A;A;;;;;A;;;;;A;;;A;;;A;AC5EvB;A;AAED;A;;;AAII;AACJ;AACA;;AACC;AACA;AACA;A;AAED;AACA;A;;;;;ACyDK;A;;;;;A;;;;AAQA;AACL;A;;;;ACgqBI;;;A;AAEF;A;AAFsB;A;AAKxB;A;;;;;A;;;;A;;;;;;;AAQA;AACA;AACA;;AACC;AACA;A;AAEC;A;AAED;AACI;A;AAEH;A;AAED;AACA;AACA;A;A;;;;;;;A;;;;;;;;AC3uBI;A;A;;;;;A;AAML;;;;A;A;;;;;A;AAMI;AAOJ;AAGA;AACA;AACA;AACA;A;;;;;A;;;;;;;AAIK;A;A;;A;AAML;AACA;AACA;AACA;A;A;;A;AAMG;;A;A;;A;AAGH;A;;A;;;;;AAaK;A;AAEJ;A;AAEC;A;A;AAGF;A;;;;AAGK;AACL;A;;;;AAGK;AACL;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;;;;;AC6GA;;A;AAEC;A;AAED;A;;;;AA4EA;AACA;A;;;;;AAgCA;;A;AAEC;A;AAED;A;;;;;AAMA;;A;AAEC;A;AAED;A;;;;;AAqEA;;A;AAEC;A;AAED;A;;;;;;AAMI;A;AAEH;A;AAEA;A;AAED;;;AACA;A;AAEC;A;AAED;A;;;;;;AAwQI;A;AAEH;A;AAEA;A;AAED;;;AACA;A;AAEC;A;AAED;A;;;;;AA8QI;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;;;;;AAyGI;AACJ;;;A;AAEC;A;AAED;;;;AACA;A;AAEC;A;AAED;A;;;;;;AAMI;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;;;;;;AAoWA;;;AACA;A;AAEC;A;AAED;A;;;;;;;;;;;A;A;A;A;;;;;;;A;A;A;A;A;A;A;A;A;A;A;A;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACvsDK;A;AAEJ;A;AAED;A;;;;AAIK;A;AAEJ;A;AAED;A;;;;AAIK;A;AAEJ;A;AAED;A;;;;AAIK;A;AAEJ;A;AAED;A;;;;AASK;AACL;A;AAEC;A;A;;;;AAKI;AACL;A;;;;AAIK;A;AAEJ;A;A;;;;;;ACzDI;A;AAEJ;A;A;AAGA;A;AAED;AACA;;AACC;AACA;A;AAED;A;;;;;;;;;;;;;;;;;;;;;;;;;;AC1BA;A;;;;AAIA;A;;;;AC+HA;A;;;;A;AA6CC;A;AAEA;;;;;;;A;AAEE;A;A;;A;AAIH;A;;;;;A;A;A;A;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACpLI;A;;;AAcJ;AACA;AACA;AACA;A;AAEC;AACA;A;AAED;AACA;A;;;A;ACmFC;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;;;AAuLzB;;;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;;;;AAKK;AACL;;;A;;;;;;AAmBK;AAED;AACJ;A;AAEK;AACJ;A;AAEA;A;AAED;;AACA;A;;;;;;AAKK;AAEJ;;;;;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;;;AAIK;A;AAEJ;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;;;;AA+CA;;;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;;;;A;AAEA;;;;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;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;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;;;AA6B5B;A;AAEC;A;AAED;A;AAEC;A;AAED;;;;A;AAEC;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;;;AAoClB;AACI;AACJ;A;AAIC;A;AAEC;AACA;A;A;A;AAKD;A;A;AAGA;A;AAED;;AAEE;;;;AACA;AAGG;A;AAIH;A;AAGD;AACA;;;;A;AAEC;A;AAED;AAGA;A;AAEC;AACA;AACA;;;;A;AAEC;A;AAEG;;;AACH;AAD4B;A;AAG7B;A;A;AAIA;A;AAID;AACA;;AACC;A;AAEC;A;AAHgB;A;A;AAOjB;A;AAED;AACA;AACA;;;A;AAEC;A;A;AAIA;A;AAED;A;AAIC;A;AAGC;A;A;AAGF;A;AAGC;A;A;A;AAKD;A;AAED;A;;;;AChtCmB;AAAd;AACL;A;;;;AAIoB;AAAf;AACL;A;;;;AAQmB;AAAd;AACL;A;;;;AAqCK;AAA2B;A;;;;AA0B3B;AAA6B;A;;;;AAyG7B;AACL;A;;;;;AAKK;AACL;AAEA;;A;AACC;;A;AAED;AACA;;A;AACC;;A;AACC;A;;AAEA;;;AACA;A;A;AAGF;A;;;;;;;;;AAKK;AACL;AACA;;A;AACC;;A;AAGD;AACA;;A;AACC;;A;AACC;AACA;A;;AAEA;;;;A;AAED;A;;AAEA;A;AAED;AACA;A;;;;;;;;;AAIK;AACL;;;;;AACA;A;;;;;;AAIK;AACL;;;AACA;A;;;;;;AAIK;AACL;;;AACA;A;;;;;;AAIK;AACL;;;AACA;A;;;;;;AAIK;AACL;;;;A;;;;;AAMA;AACA;A;;;;;;AAOK;AACL;;;;;;AACA;;AAgBA;AAMA;A;AAEC;A;A;AAMA;AACA;A;AAKC;A;A;A;AAQE;A;AACF;AACA;A;A;AAIF;A;;;;;;;;;AAIK;A;;;;;;;;A;;;;;;;;AAML;AACA;AACA;AACA;AACA;AACA;A;;;;AAIK;AACL;;;A;;;;;;AAIK;AACL;;;A;;;;;;AAIK;AACL;;;A;;;;;AAKK;AACL;A;;;;;AAKK;AACL;;;AACA;A;;;;;AAsCK;AAED;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;;;AAIK;AAAkC;A;;;;AAYlC;AACL;AACA;AACA;A;;;;AAIK;AACL;AACA;AACA;A;;;;AAIK;AACL;AACA;AACA;A;;;;AAIK;AACL;AACA;A;AAEC;AACA;A;AAEA;AACA;A;AAED;AACA;A;;;;AAOiB;AAAZ;AACL;A;AAIC;A;AAEA;A;AAEA;A;A;;;;;AAkBI;AACL;;;;;AACA;;;;;AACA;;;A;;;;;;;;;;AAeK;A;;;;;;;;;A;;;;;;;;;AAOL;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;;;AAaK;AACL;AACA;A;;;;AAIK;AACL;AACA;A;;;;AAMK;A;AAEJ;A;AAED;AACA;A;;;;AAIK;AACL;A;AAEC;A;AAED;A;;;;;;;AAKK;AACL;;;;AACA;A;;;;;AAKK;AACL;A;;;;AAOK;AACL;A;;;;;AAMK;AACD;AAEJ;;A;AACC;A;;AAEA;;;A;AAEC;A;AAED;A;AAEC;A;AAED;A;AAGD;AAkBA;A;;;;;;AAIK;AACL;A;AAEC;A;A;AAIA;A;A;AAIA;A;AAGD;AACA;AAGA;AACA;AAEA;AACA;AAEA;;A;AACC;A;;AACS;;;A;AACT;A;AAEA;A;A;AAGD;A;;;;;;AAQK;AACL;;;A;;;;;;AAIK;AACL;;;A;;;;;;AAKK;AACF;;A;AAGF;A;AAGD;AACA;AACA;;AACA;AACA;A;;;;;;;AAKK;AAEL;;;;AACA;A;;;;;;AAKK;AACF;;A;AACF;A;AAGD;AACA;;;A;;;;;;;AAKK;AAEL;;;;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;A;;;;;AAKK;A;AAEJ;A;AAED;;AACA;A;;;;AAMK;A;AAEJ;A;AAED;;A;AAEC;A;AAED;A;;;;;;AAMQ;AACR;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;;;;ACpnCK;A;AAEJ;A;AAED;;A;AACC;A;AAED;A;;;;;;AAKK;AACL;;;A;;;;;AAMA;AAOA;AACA;A;;;;;;;;;;AAUK;AACL;;A;AAGC;AACA;AACA;AACA;AACA;AACA;A;AAGE;A;AACF;AACA;AACA;AACA;AACA;AACA;A;A;AAIA;AACA;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;AACA;AAEA;A;;;;;AAkBK;A;AAGJ;A;A;AAKI;;;A;AAEF;A;AAFyC;A;A;AAQ5C;;;;;A;AAEE;A;A;;AAKF;A;;;;AAKK;AACL;;;;;A;AAEE;A;A;;AAGF;A;;;;;;;;AAMK;AACL;;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACjPA;A;;;AAIG;A;AACF;AACA;AACI;;;AACH;AADgC;A;A;A;AAKjC;A;A;;;A;;;;;ACJI;A;AAGJ;AAEA;A;AAED;AAEA;A;AAEC;AACA;A;AAGD;AACA;;A;AAGE;AACI;AACJ;;;;A;A;;;;;A;A;AAKC;A;A;AAKE;;;;AACJ;;;;AACA;AACA;A;A;A;;;;;A;A;;;;;A;;;;;;;AC+DI;A;A;;;;;A;A;;;;;;A;;;;;;;AAmBA;A;A;;;;;A;A;;;;A;;;;;AC5GA;AAA+B;;;A;;;;;;AAQ/B;AAAkC;;;A;;;;;A;AAOtC;A;AAED;A;;;;AAcA;A;;;;AC/BA;A;A;AAEC;A;A;AAEA;A;A;AAEA;A;A;AAEA;A;AAED;A;;;ACSK;AAAyB;A;;;;;AAuCzB;AACL;;;A;;;;;;;AAMK;A;A;;;;;A;AAIL;;;A;A;;;;;A;A;AAKC;A;A;;;;;A;;;;;;AASI;A;A;;;;;A;AAIL;;AACC;;;A;A;;;;;A;A;AAKC;AACA;A;AAED;AACA;AACA;A;AAED;A;;;;;;AAMK;A;A;;;;;A;AAIL;;;A;AAEC;A;A;AAGA;A;AAGD;A;AAGC;A;A;;;;;A;;;;;;AAQI;A;A;;;;;A;AAIL;;AACC;;;A;AAEC;AACA;A;AAED;AACA;AACA;A;AAED;A;;;;;;AAQK;A;A;;;;;A;AAIL;;;A;AAEC;A;A;A;;;;;A;A;;;;;A;;;;;;AAUI;A;A;;;;;A;A;;;;A;;;;AAoCA;A;AAEJ;A;AAEE;A;AACF;A;AAED;A;;;;A;AAmCC;A;AAED;A;;;;;;;AChPA;A;AAEC;A;A;AAGA;A;A;AAGA;A;AAGD;A;;;AAeK;A;AAEJ;A;AAEE;A;AACF;A;AAED;A;;;;AAyBK;A;AAEJ;A;AAEE;A;AACF;A;AAED;A;;;;AAMK;A;AAEJ;A;AAEE;A;AACF;A;AAED;A;;;;AAMK;A;AAEJ;A;AAEE;A;AACF;A;AAED;A;;;;ACjFK;A;AAEJ;A;AAED;A;;;;AAKA;A;AAEC;A;AAED;AACA;AACA;A;;;;A;AAeC;A;A;;;AAuDI;A;AAEJ;A;AAED;A;;;;AAGK;A;AAEJ;A;AAEG;AACD;A;AACF;A;AAED;AAGA;AACA;A;;;;AAKK;A;AAEJ;A;AAEG;AACJ;A;AAEC;A;AAED;AACA;A;;;;AAoBI;AACJ;A;AAEC;A;AAED;AACA;A;;;;;;;AAGK;AACL;A;AAEC;A;AAED;;;AACA;AACA;;;;;AACC;;;;A;AAIC;;A;A;A;;;;;A;AAKD;A;;A;;;;;A;;;;;;;AAgBI;A;AAEJ;A;A;;;;;A;;;;;;AAQI;A;AAEJ;A;A;;;;;A;;;;;;AAOI;AACL;AACC;A;AAEC;A;AAED;;;;AACA;A;AAMC;AACA;A;A;AAIA;AACA;A;A;;;;;A;A;;;;;;AASG;A;AAEJ;A;A;;;;;A;;;;;;AASI;A;;;;A;;;;AA+CL;AAEA;;AACC;AAD8B;A;AAI3B;A;;A;AAEF;AACA;A;AAHe;A;AAOjB;A;;;A;AClUC;A;AAED;A;;;A;AA8BC;A;AAED;A;;;;ACzCA;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;;;AAIkB;AACnB;A;;;ACcK;AAED;AACJ;AACA;;;;;;;A;AAEE;AACA;A;A;;A;AAID;AACA;A;AAGD;;;;;;;A;AAEE;A;AAEA;A;AAED;A;;AAED;A;;;;AAKK;AACL;A;;;;AAKK;AACL;A;;;;AAIK;AACL;A;;;;AAGK;AAA8B;A;;;;AAC9B;AAA8B;A;;;;AC/E9B;AAAoC;A;;;;AACpC;AAAoC;A;;;;AACpC;AAAoC;A;;;;AACpC;AAAoC;A;;;;;;;;;;;;;;;;;;;;A;A;A;A;A;A;A;A;;A;A;A;A;A;A;A;A;A;A;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACVzC;;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;AACA;;;;;AACC;AACA;AACA;A;;AAOD;AAKA;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;AAOA;AACA;AACA;;;;;AACC;AACA;A;;AAMD;A;AAKA;A;AAKA;A;AAIA;A;AAIA;AACA;AACA;;;;;AACC;AACA;A;;AAQD;A;A;AAOF;A;;;AAIA;AACA;A;;;AAMI;AACJ;AACA;A;AAEC;A;AAED;;;A;AAEC;AACA;A;AAED;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;;;;;AAoCK;AACL;A;;;;AAIA;A;;;;;AAIA;;;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;;;AAWA;A;;;;AAIA;AACA;AACA;;;;;A;;;;AAIA;AACA;A;;;AAIA;A;;;;AAGc;AACV;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;;;;;;;AAkC8B;AAC1B;A;AAEH;A;AAEC;A;AAED;A;AAEC;A;AAED;A;AAEC;A;AAGD;AACA;A;AAGA;A;AAEC;A;AAED;A;AAEC;A;AAED;AACA;A;AAED;A;AAEC;A;AAED;AACA;A;;;;AAGmB;A;AAElB;A;A;AAGA;A;AAED;;A;AACC;;A;A;AAIA;A;AAED;A;;;;AAIA;A;;;AAIA;A;;;;;;AAG+B;A;AAE9B;A;AAGD;;AACA;A;AAEC;A;AAED;;AACC;A;AAED;;;A;;;;AAGK;A;A;AAGJ;A;AAEA;A;A;;;;;AAII;A;AAEL;;;;A;AACC;A;AAEA;;;A;AAEI;;;AACH;;;;A;AACC;A;AAF4B;A;A;A;AAM/B;A;;;;;;AAGK;A;AAEJ;A;AAED;A;AAEC;A;AAED;A;AAEC;AACA;A;AAED;AACA;AACA;AACA;;AACC;AACA;A;AAED;AACA;AACA;A;;;;AAGK;A;AAEJ;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;;;;;AAKK;AACL;AAEC;AACA;A;AAGA;;;AACA;A;AAEC;A;A;AAGD;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;;;;;AAII;AACL;A;A;AAGC;A;AAEA;A;AAED;A;;;;A;AAOC;A;AAED;A;;;A;AAKC;A;AAED;A;;;;AAGK;AACE;A;AACP;;;A;AACC;A;AAEC;A;AAED;AACA;;;A;A;AAIC;A;AAED;AACA;AACA;AACA;AACA;A;AAGA;A;A;A;;;;;;;;;;AAII;AACL;AACA;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;;;;;;;;;;AAGK;AACE;A;AACP;;;;A;AACC;A;AAEC;A;AAED;AACA;AACA;AAEA;AACA;;A;AACC;;AACuC;A;;AACC;A;A;AAGzC;;;A;AAGA;A;AAEC;A;AAED;AACA;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;;;;;AAII;AACL;A;;;;AAGK;AACE;A;A;AAEN;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;A;;;;AAII;AACE;A;A;AAEN;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;A;;;;AAII;AACE;A;A;A;AAGL;A;AAED;A;A;AAGC;A;AAED;A;A;AAGC;A;AAED;A;AAEA;A;A;;;;;AAIiB;AAAb;AACL;AACA;AACA;;AACA;;A;A;AAEC;;;;A;AACC;A;A;AAEA;;A;A;AAEA;A;;AAEA;A;A;AAED;A;AAED;A;;;;;;AAGK;AACL;AACA;AACA;;;A;AACC;A;AAED;AACA;;;;;A;AACC;AACA;AACA;AACA;AACA;A;AAED;A;;;;;AAGK;AACL;AACA;AACA;A;AAEC;A;AAED;AACA;AACA;AACA;AACA;A;;;;AAGK;AACL;AACA;AACA;A;AAEC;A;AAED;AACA;AACA;AACA;AACA;A;;;;;AAGK;AAEJ;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;;;;;;AAGK;AAEJ;AACA;AACA;AAEM;A;A;A;AAGL;A;AAED;AACA;AACA;AACA;A;AAGA;AACA;AACA;A;AAGA;A;A;AAIA;A;AAGD;;;A;;;;;AAGK;AACL;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;;;;ACjwBK;A;AAEJ;A;AAED;A;;;;AAiCK;AACL;A;;;;AAGK;A;AAEJ;A;AAED;A;;;;AAGK;A;AAEJ;A;AAED;A;;;;AAGK;AAA4B;A;;;;AAE5B;AAA2B;A;;;;AAE3B;A;AAEJ;A;AAED;A;AAEC;A;AAED;A;;;;AAGK;AAAwB;A;;;;AAExB;AAA6B;A;;;;AAE7B;AAAwB;A;;;;AAIxB;AAA4B;A;;;;AAuB5B;A;AAEJ;A;AAED;A;;;;;;AAGK;A;AAEJ;A;AAEG;AACJ;;;;;AACC;A;A;;;;;A;A;;AAKD;A;;;;AAMK;A;AAEJ;AACA;A;AAED;A;;;;;AAGK;A;AAEJ;A;;A;A;;A;;;;;;AAMI;A;AAEJ;A;;;;A;A;;;;A;;;;AAMI;AACL;A;;;;AAGK;AACL;A;;;;AAGK;A;AAEJ;A;AAED;AACA;A;;;;AAGK;A;AAEJ;A;AAED;AACA;A;;;;AAGK;A;A;AAGJ;AACA;A;AAEA;AACA;A;AAEA;AACA;A;AAEA;AACA;A;AAEA;AACA;A;AAED;A;;;;;AAGK;A;AAEJ;A;AAED;AACA;;;A;;;;;;AAGK;A;AAEJ;A;AAED;AACA;;;A;;;;;;AAGK;A;AAEJ;A;AAED;AACA;;;A;;;;;;AAGK;A;AAEJ;A;AAED;AACA;;;A;;;;;AAGK;A;AAEJ;A;AAED;AACA;A;;;;AAGK;A;AAEJ;A;AAED;AACA;A;;;;AAGK;A;AAEJ;A;AAED;AACA;A;;;;AAGK;A;AAEJ;A;AAED;AACA;A;;;;AAGK;A;AAEJ;A;AAED;AACA;A;;;;AAGK;A;AAEJ;A;AAED;AACA;A;;;;AAGK;A;AAEJ;A;AAED;AACA;A;;;;AAGK;A;A;AAGJ;A;AAEA;A;AAEA;A;AAED;A;;;;;AAIK;A;AAEJ;A;AAED;AACA;A;AAEC;A;AAED;AACA;AACA;A;;;;AAIK;AAAoC;A;;;;;;AAGpC;A;AAEJ;A;AAEG;AACJ;;;;;AACC;A;A;;;;;A;A;;AAKD;A;;;;AAiCK;AAIL;;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;AAED;A;A;AAGF;A;;;;;;AAIK;A;AAEJ;A;AAED;AACA;AACA;;A;AACC;A;;AAEA;AACA;;;A;AACC;;A;AAED;;AACA;A;A;AAGA;A;A;AAGA;A;AAED;AASA;AACA;A;;;;;;;AAOK;AACL;AACA;;;;;;AACC;;A;AACC;AACA;;;;;;;A;AACC;;A;AAED;A;AAED;;A;;AAED;A;;;;;;;;AAWK;AASL;AACA;AAQI;AAOJ;AAEA;;AACC;;;;AACA;AACA;AAMA;;;;;AACC;AACA;;A;AAIC;;A;AAED;AACA;;;;;AACC;AAEI;AACA;AACJ;;A;AACC;A;;AAIA;AACA;;A;AACC;;A;AAED;A;AAID;;;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;;;;;;;;;AAKK;AAEL;AACA;;A;AACC;;;;;AACC;AACA;;A;AACC;AACA;;A;AAED;;A;A;;;;;;;A;A;;A;A;AAMD;A;A;;AAE8C;A;;;;;;A;;;;;AAmB/C;A;;;;;AA4EK;A;AAEJ;A;AAED;;;A;AACC;A;AAED;A;;;;;AAGK;A;AAEJ;A;AAED;AACA;A;;;;;AAGK;A;AAEJ;A;AAED;AACA;;;A;;;;;A;AAUC;A;AAED;A;AAEC;A;A;AAgBA;AACA;AACI;;;AACH;AACA;A;AAEI;A;AACF;A;A;AAL6B;A;AAShC;A;AAGD;A;AAEC;A;AAED;AACI;;;AACH;AACA;A;AAEI;A;AACF;A;A;AAL6B;A;AAShC;A;;;A;AAWC;A;A;AAMA;A;AAID;A;;;A;AAKC;A;AAGD;A;AAEC;A;A;AAMA;A;A;A;AAMA;A;A;AAOC;A;AAID;A;AAGA;AACA;A;AAEC;A;AAED;;;;;;A;AAEE;A;A;;AAGF;;;;;;A;AAEE;A;A;;AAGF;A;AAGA;AACA;A;AAEC;A;AAID;A;AAGA;A;AAGA;A;AAGA;AACA;A;AAEC;A;AAED;;;;;AACC;AACA;A;AAEC;A;A;AAGA;A;A;AAGA;A;A;AAGA;A;A;AAGA;A;A;;AAGF;A;AAGD;A;;;A;AA6tBC;A;AAED;A;;;AA2HA;A;;;ACliEK;AACL;A;;;;AAKK;A;AAEJ;A;A;AAGA;A;AAED;A;;;;AA+DK;A;AAEJ;A;AAED;A;;;;AAwCK;A;AAEJ;A;A;;;;AAMI;A;AAEJ;A;A;AAGA;A;A;;;;AAOI;A;AAEJ;A;A;AAIA;A;A;AAGA;A;A;;;;AASI;A;AAEJ;A;AAED;A;;;;AAKK;AACL;AACA;A;;;;;AAKK;AACL;AACA;;;A;AACC;A;AAGD;A;;;;;;AAKK;AACL;AACA;;;A;AACC;A;AAGD;A;;;;;AAQK;AACL;A;;;;AAQK;AACL;A;;;;;AAWK;AACL;AACA;AACA;;;A;;;;;;AAUK;AACL;AACA;AACA;;;A;;;;;AAoXK;AACL;A;A;AAGC;A;AAEA;A;AAED;A;;;;;AA4EK;AACL;;A;AACC;;;A;AAED;AACA;;;;;;AACC;;A;AACC;;;;;A;A;AAEE;A;AAED;;A;A;AAGF;;A;;AAED;A;;;;;;AAMK;AACL;AACG;;;;AAAH;;A;AACC;;;A;AAED;A;;;;;;AAOK;AACF;;;;AAAH;;A;AACC;;;A;AAED;A;;;;;AAKK;AACL;A;A;AAGC;A;AAEA;A;AAED;A;;;;AAqDK;AACL;AACA;A;A;AAGC;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAED;A;;;;AAIK;A;AAEJ;A;AAED;A;;;;;;AAQK;A;;;;A;;;;;AA+EA;AACL;A;;;;AAKK;AACL;A;;;;;AA6BuB;AAAlB;AACL;AACA;AASA;;AAEI;A;AAEH;A;AAEA;A;AAED;A;AAEC;A;AAED;AACA;AACA;A;AAIC;AACA;AACA;A;AAEA;A;A;;;;;;AAQI;AACL;AACA;AACA;AAEA;AAEA;AACA;A;AAEC;A;AAED;AACA;AACI;AACA;;;AACH;;A;AAKC;A;A;AAKA;AACA;AACA;A;AAEA;A;AAED;AAjBsB;A;AAmBvB;A;;;;;AAOK;A;AAEJ;A;A;AAGA;A;A;AAGA;A;AAED;AACA;AACA;AACA;A;;;;AAIK;A;AAEJ;A;A;AAGA;A;AAED;A;;;;AAQK;A;AAEJ;A;A;AAGA;A;AAED;;;A;AAEC;A;AAED;A;;;;AAKK;AACL;AACA;AACA;A;;;;AAKK;AACL;A;A;AAGC;A;AAEA;A;AAED;A;;;;AAKK;AACL;A;A;AAGC;A;AAEA;A;AAED;A;;;;A;AAKC;A;AAED;A;;;AAKK;AACL;A;A;AAGC;AACA;AACA;A;AAED;A;;;;AAKK;AACL;A;A;AAGC;AACA;AACA;A;AAED;A;;;;;;;AAqDK;AACL;AACA;A;;;;;;A;;;;;;;;AAMK;AACL;A;AAEC;A;AAED;AACA;AACI;A;AAEH;AACA;AACA;A;AAEA;A;AAED;;;;A;AAEC;A;AAED;A;;;;;;AAMmB;AAAd;AACL;AACA;AACA;;A;;;;;;;AAKmB;AAAd;AACL;A;AAEC;A;AAED;AACA;;AACI;A;AAEH;A;AAEA;A;A;;;;A;;;;;AAyBI;AACL;AACA;AACA;A;;;;;AAgBK;AACL;AACA;AACA;;;A;AACC;A;AAED;A;;;;;AAKK;AACL;AACO;A;A;AAIN;A;AAEA;A;AAJA;A;A;;;;AAUI;AACL;AACO;A;A;AAIN;A;AAEA;A;AAJA;A;A;;;;AAUI;AACL;AACO;A;A;AAIN;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAVA;A;A;;;;;AA8C8B;AAAL;AAArB;AACL;AACA;AACA;AACA;AACA;;AACI;A;AAEH;A;AAEA;A;A;AAGA;AACA;A;AAED;AACA;;AACI;A;AAEH;A;AAEA;A;AAED;A;;;;;AAKK;AACL;AACO;A;A;AAIN;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAZA;A;A;;;;AAkBI;AACL;AACA;AACA;A;;;;AAKK;AACL;AACA;AACA;A;;;;;AAwHK;AACE;A;A;AAEN;A;AAEA;A;AAID;;;A;;;;;;;;AAQK;AACL;AACA;A;;;;;;A;;;;;;AAQsB;AAAjB;AACL;AACA;AACA;;;A;;;;;AAIK;AACL;A;AAEC;A;A;AAIA;A;AAKD;A;AAGC;A;AAEC;A;AAED;AACA;A;AAGD;A;AAEC;A;AAED;AACA;A;;;;AAKK;AACL;AACA;A;A;AAGC;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAED;A;;;;AAMK;A;AAGJ;A;A;AAGA;A;AAED;A;;;;;A;AAmYC;A;AAED;AACA;AACA;;;;A;;;;;;AAaK;AACL;;A;AACC;;A;AAID;;;A;AAGC;AACA;AACA;AACA;A;A;AAIC;A;AAED;;A;AAEC;A;AAEA;A;AAED;A;A;AAID;A;;;;;;AAMK;AACL;;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;A;AAOF;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;;;;;AASW;AACX;;;A;;;;;AAIY;AACZ;;;A;;;;;AAIgB;AAChB;;;A;;;;;AAIiB;AACjB;;;A;;;;;AAIgB;AAChB;;;A;;;;;AAIiB;AACjB;;;A;;;;;AAIa;AACb;;;A;;;;;AAIe;AACf;;;A;;;;;AAIiB;AACjB;;;A;;;;;AAIkB;AAClB;;;A;;;;;AAImB;AACnB;;;;;;;A;;;;;AAImB;AACnB;;;;;;;A;;;;;AAImB;AACnB;;;;;;;A;;;;;AAImB;AACnB;;;;;;;A;;;;;AAmBW;AACX;;;AACA;;AACA;;;A;AACC;A;;AAEA;A;AAED;;;A;;;;;AAIW;AACX;;A;AACC;;AACA;AACA;A;AAED;;;;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;A;A;A;A;A;A;A;A;A;A;A;A;A;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACz2EI;;;AACH;AACA;AAFsB;A;A;;;AAoClB;AACL;A;;;;AAGK;AACL;AACA;A;;;;;;;AAIK;AACL;AACA;A;AAEC;AACA;A;AAED;A;A;A;;;;;;;A;A;A;;;;;;;A;A;;;;;;;A;A;AAYA;A;;;;AAIK;AACL;;AACC;A;AAEC;A;AAED;AACA;A;A;;;;AAKI;A;AAEJ;AACA;A;AAED;;;;A;AAEC;A;AAED;A;AAEC;A;A;;;;AAKI;A;AAEJ;AACA;A;AAED;;;;A;AAEC;A;AAED;A;AAEC;A;A;;;;AAUI;A;AAEJ;A;AAEA;A;A;;;;AAMI;A;AAGJ;A;AAGD;A;AAEC;A;AAGG;A;AAEH;A;AAGC;A;A;AAIA;A;AAGC;A;A;A;AAID;A;A;AAIA;A;A;AAMF;A;AAEC;AACA;A;AAEA;A;AAEC;A;A;AAQF;AACA;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;AAGD;AACA;AACA;AACA;A;A;A;AAID;AACA;AACA;AACA;A;A;AAIA;AACA;A;AAEA;AACA;A;AAEA;AACA;A;A;AAKA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;A;AAGD;A;;;;AAIK;A;AAEJ;AACA;;;;;;A;AAEE;AACA;A;AAED;A;;A;AAGF;A;;;;AAIK;AACL;AACA;A;;;;AAIK;AACL;A;AAEC;A;AAED;AAEI;AACA;;;A;AAEF;A;A;AAGA;A;AAEG;A;AAEH;A;AAEA;A;AAED;AAbkB;A;AAenB;A;;;;AAIK;A;AAEJ;A;AAED;A;;;;AAIK;A;AAEJ;A;AAED;A;;;;AAIK;AACL;AACI;A;AAEH;A;A;AAGC;A;AAEA;A;A;AAGF;A;;;;AAKK;AACD;A;AAEH;A;AAEA;A;AAED;A;;;;A;AAOC;A;AAED;A;;;;AAIK;AAEL;A;AAEC;A;AAEA;A;A;A;AAKC;;AAAe;A;AACf;A;A;A;A;AAQA;AACA;A;AAEA;AACA;A;AAED;AACA;A;A;AAIA;AACA;AACA;A;A;AAKA;AACA;A;AAGD;A;;;;;AAIK;AAA6B;A;;;;AAG7B;AAA6B;A;;;;AAG7B;AAA6B;A;;;;AAG7B;AAA6B;A;;;;AAG7B;AAA6B;A;;;;AAG7B;AAA8B;A;;;;AAO9B;AAA6B;A;;;;AAG7B;AAA6B;A;;;;AAG7B;AAA6B;A;;;;AAG7B;AAA6B;A;;;;AAG7B;AAA6B;A;;;;AAG7B;AAA8B;A;;;;AAG9B;AACL;A;;;;AAIK;AACL;A;;;;AAIK;AACL;AACA;AACA;AACA;AACI;;A;A;AAGF;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;A;AAGA;A;AAGD;AACA;AACA;AACA;AAtBa;A;AAwBd;AACA;AACA;AACA;A;;;;;;ACxcK;AACL;A;;;;;A;;;;;AAIK;AACL;A;;;;;A;;;AAIK;AACL;AACA;A;;;AAGK;A;AAEJ;AACA;A;AAGD;AACA;AACA;;AACC;A;AAED;AACA;AACA;A;;;;AA2BA;;AACA;AACA;AACA;AACA;A;;;;AAIK;A;AAGJ;A;AAED;AACA;AACA;AACA;A;;;;;;AAGK;A;;;;;A;;;;;;AAEA;A;;;;;A;;;;AAEA;A;A;AAGJ;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAED;A;;;;AAGK;AACL;A;;;;;;AAKK;A;;;;A;;;;;;;AASL;;AACA;AACA;;;;AACA;AACA;A;;;;;;AAWA;;AACA;AACA;AACA;AACA;A;;;;;;AAMA;;;;A;;;;;;;;AASA;;AACA;AACA;;;;AACA;AACA;A;;;;;;;;AA4BA;;AACA;AACA;;;;AACA;AACA;A;;;;;;AAuBa;AACb;;AACA;;A;AACC;;A;AAED;A;;;;AAOA;A;;;;;;A;A;;;;;;;A;AAQI;;;A;A;;;;;;;A;AAIH;AACA;AALiE;A;AAOlE;A;;;;AAGwB;AAAnB;A;AAEJ;AACA;A;AAED;AACA;;;AACA;A;;;;;;AAGK;AACL;AACA;AACA;AACA;AACA;AAEA;;;A;AACC;;;AACA;AACA;;A;A;AAEA;;;AACA;AACA;;A;;AAEA;A;A;AAED;AACA;A;;;;;;AAGK;A;AAEL;;A;AACC;A;;AAEA;A;A;A;;;;;AAKI;AACL;A;AAEC;A;AAED;AACA;A;;;;;AAGK;A;AAEL;;;;;;;;;A;AACC;A;A;AAEA;A;A;AAEA;A;A;AAEA;A;A;AAEA;;A;AACC;A;;AAEA;A;A;A;AAGD;A;A;AAEA;A;A;AAEA;A;;AAEA;A;A;A;;;;;AAMI;AACL;AACA;AACA;AACA;A;;;;AAKK;AACL;AACA;AACA;AACA;A;AAGC;AACA;A;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;A;;;;;AAGK;A;AAEL;;;;;;;;;;A;AACC;A;A;AAEA;A;A;AAEA;A;A;A;AAGC;A;AAEA;A;A;A;AAGD;A;A;AAEA;;A;AACC;A;;AAEA;A;A;A;AAGD;A;A;AAEA;A;A;AAEA;A;;AAEA;A;A;A;;;;;;AAII;A;AAEL;;;;;;;A;AACC;A;A;AAEA;A;A;AAEA;A;A;AAEA;A;A;AAEA;A;A;AAEA;A;;AAEA;A;A;A;;;;;;AAII;A;AAEL;;;;;;;A;AACC;A;A;AAEA;A;A;AAEA;A;A;AAEA;A;A;AAEA;A;A;AAEA;A;;AAEA;A;A;A;;;;;;AAII;A;AAEL;;;A;AACC;A;A;AAEA;A;;AAEA;A;A;A;;;;;;AAII;A;AAEL;;;A;AACC;A;A;AAEA;A;;AAEA;A;A;A;;;;;;AAII;A;AAEL;;;;;;A;A;AAEE;A;AAEA;A;A;A;AAGD;A;A;AAEA;A;A;AAEA;A;A;AAEA;A;;AAEA;A;A;A;;;;;;AAII;AACL;;A;AACC;;A;AACC;;A;AACC;;A;AACC;A;;AAEA;;;AACA;A;AAED;A;AAED;;A;AACC;A;;AAEA;;;AACA;A;A;;AAGD;A;AAED;;;;;;A;A;AAGG;A;AAEA;A;A;AAGF;;A;;A;AAGA;A;AAEA;A;AAED;A;A;AAGD;;;;;A;AACC;A;A;AAEA;A;A;AAEA;A;A;AAEA;A;;AAEA;A;A;A;;;;;;AAIsB;AAAlB;AACL;A;AAEA;;;A;A;A;AAGC;A;;AAGA;AACA;A;A;AAGG;A;AAEJ;;A;AACC;A;;AAEA;AACA;A;A;AAGD;;;A;AACC;AACA;;;AACA;AACA;A;AAEC;A;AAEA;A;AAED;A;A;AAEA;A;;AAEA;;A;AACC;A;;AAEA;A;A;A;;;;;;AAUG;AACF;AAAH;;A;AAII;;A;AACF;AACA;A;A;AAMA;A;AAED;AACA;AACA;AACA;AACA;AACA;;AACA;AACA;A;A;;;;;;;AAKI;AACL;A;AAEC;AACA;A;AAED;A;AAEC;AACA;A;AAED;A;;;;AAKK;A;AAEJ;AACA;A;A;AAGA;AACA;A;A;;;;;;AAII;A;AAEJ;A;AAGE;;;AAAH;;A;AACC;AACA;;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;;;;;;;AAOE;AACL;AACA;AAEA;;A;AACC;;A;AACC;A;;AAEA;A;A;;A;A;AAQF;;;A;AACC;;;A;;A;AAGA;;A;;A;A;AAKD;;;;;;;;;;;;;;;;;;;;;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;AACA;A;A;A;AAEA;AACA;A;A;A;A;;;;A;A;AAKG;;A;A;;A;A;;;;;A;AAMJ;AACA;A;;;;;;;AAIuB;AAAlB;AACL;;A;AACC;;A;AACC;A;;AAEA;A;A;;A;A;AAQF;;;A;AACC;;;A;;A;AAGA;A;;A;A;AAMD;AACA;;A;AACC;;A;AAEE;;A;A;;A;A;;;;A;;;;;;;AAW2B;AAAzB;AACL;AACA;AAEO;A;AACP;;;;;;;;;;;;;;A;AACC;A;A;AAEA;A;A;AAEA;A;A;AAEA;A;A;AAEA;;;A;AACC;A;;AAEA;A;A;A;AAGD;;;A;AACC;A;;AAEA;A;A;A;AAGD;;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;AACA;AACA;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;AAQE;AAAH;;;;;;;A;AACK;AACJ;;;A;AACC;;A;A;AAEA;;;A;;AAKA;AACA;;;;;AACC;;;A;;A;AAGF;AACA;AACA;A;AAED;;A;AACC;;;A;AAEC;AACA;A;AAED;A;;AAEA;A;AAEG;;;A;A;AAGD;A;AAEA;A;A;AAGF;;;AARwB;A;A;AAWxB;A;AAEA;A;A;A;AAGD;AAGA;;A;AACQ;;A;AACP;;;;A;AACC;AACA;;AACA;A;A;AAEA;AACA;;AACA;A;A;AAEA;AACA;;AACA;A;A;A;AAKF;A;A;AAAA;A;;AAEA;A;A;AAED;A;;A;;;;;;;;;AAMA;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;;;;;;AAexB;A;A;;;;;;;A;AAIL;AACA;;;;A;A;;;;;;;A;AAIA;A;;;;;;;A;;;;;AAIK;AACL;AACA;AACA;AACA;AACI;;;AACH;AACA;AACA;;AACC;A;A;AAGA;A;A;AAIA;A;AAID;AAGA;AAEA;;;A;A;AAGE;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAba;A;AAkBf;;;;AAGA;;A;AACC;AACA;;;;;A;AAGC;A;A;AAMA;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;AAGD;;A;AACC;AACA;A;AAED;;;AACA;AAEA;;A;AACC;AACA;A;AAED;;;A;AACC;AACA;AACA;AACA;A;A;AAEA;AACA;AACA;AACA;A;AAED;AACA;A;A;AAKE;AACA;A;A;AAIA;AACA;A;A;AAGF;;A;AAMD;;A;AACC;AACA;;AACC;AACA;;A;AACC;;;AACA;A;AAED;;A;AAEC;A;AARqB;A;AAWvB;A;A;;;;;;AAII;AACL;AACI;;;AACH;AAEA;AACA;;A;AACC;;;;A;AAEC;A;A;AAGF;;AAViC;A;A;AAajC;A;A;;;;;;;AC/jCI;A;;;;;A;;;;;;;;AAIA;A;AAEJ;AACA;AACA;AACA;AACA;AACA;A;A;AAGA;AACA;A;AAGD;;;;;A;AAEC;AACA;A;AAEA;A;AAED;A;;;;;;;AAGK;A;A;;;;;A;A;;;;;A;;;;;;AASA;AACL;;;;A;A;A;;A;AAKC;A;AAED;A;;;;;;AAcK;AACF;;;AAAH;;A;AACC;;A;;AAEA;A;AAED;AACA;AACA;A;;;;;AAGK;AACL;A;;;;AAGK;AACL;A;;;;;;;;AAGK;AACL;;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;;;;AAMK;AACL;A;;;;;AA2FiB;AAAZ;A;AAGJ;AACA;A;A;AAIA;A;AAED;AACA;AACA;A;;;;;AAIK;AACL;AACC;;A;AAEC;A;AAED;;;;;A;AACC;A;AAED;;A;A;AAEE;A;A;AAGA;A;AAED;AACA;A;AAED;;A;AACC;;AACA;A;A;A;;;;;;AAQG;AACL;;A;AACC;A;AAGD;AACC;;A;AAEC;A;AAED;;;A;AACC;;AACA;A;AAED;A;AAED;A;;;;;AAOA;;;;;;;A;AAEE;A;A;;AAGF;A;;;;AAuBK;AACL;;AACA;;A;AACC;;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;;ADrY0B;A;A;;A;;A;A;A;;ACuQA;A;A;A;A;;;;;;;;;;;;;ACzU1B;;;;AACA;;AACC;AAEA;;;A;AACC;A;;AAEA;A;A;AAIF;A;;;;;;;;AA6BA;;AAAyC;A;;;A;;;;;;AAUpC;AAAsC;;;A;;;;;;ACjFvC;;;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;;;;;;;AAaF;AACA;;A;AAEC;AACA;AACA;AACA;A;AAED;AASA;AACA;;;;AAEA;;;;;AAAqC;A;AAErC;AACA;AACC;;;;;AAAsC;A;AAEtC;;;;;AAAuC;A;A;AAGtC;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;;;;;AAAwC;A;AAExC;;;;;AAAqC;A;A;AAGpC;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;;;;;AASD;;AACA;AACI;;;AACH;AADkB;A;AAGnB;AACA;A;;;;;AA4DK;AAAqC;A;;;;AACrC;AAAqC;A;;;;AACrC;AAAqC;;;;A;;;;;AAGrC;AAAwB;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AClN7B;AACA;A;;;AAGK;AACL;;;AACA;AACA;A;;;AAGK;AAAkC;A;;;;AAElC;AAAgC;;;A;;;;AAEhC;AAAkC;A;;;AAavC;AACA;A;;;AAGK;AACL;;;AACA;AACA;A;;;AAGK;AAAiC;A;;;;AAEjC;AAA+B;;;A;;;;AAMpC;AACA;A;;;AAGK;AACL;;;AACA;AACA;A;;;AAGK;AAAmC;A;;;;AAEnC;AAAiC;;;A;;;;AAMtC;AACA;A;;;AAGK;AACL;;;AACA;AACA;A;;;AAGK;AAAkC;A;;;;AAElC;AAAgC;;;A;;;;AAMrC;AACA;A;;;AAGK;AACL;;;AACA;AACA;A;;;AAGK;AAAoC;A;;;;AAEpC;AAAkC;;;A;;;;AAMvC;AACA;A;;;AAGK;AACL;AACA;A;;;AAGK;AAAoC;A;;;;AAEpC;AAAkC;;;A;;;;AAMvC;AACA;A;;;AAGK;AACL;;;AACA;AACA;A;;;AAGK;AAAqC;A;;;;AAErC;AAAmC;;;A;;;;AAMxC;AACA;A;;;AAGK;AACL;;;AACA;AACA;A;;;AAGK;AAAsC;A;;;AAEtC;AAAoC;A;;;;AA6DzC;AACA;AACA;;;;;;A;A;;A;;AACC;AACA;A;;AAED;AACA;AACA;;;;;;AACC;A;;AAED;A;;;;AAGK;A;AAEJ;A;AAED;A;;;;AAKK;AACL;A;;;;;AAKK;AACL;;;;;;AACC;A;;A;;;;;;AAYI;AACL;;;;;;AACC;A;;A;;;;;AAWI;AACL;A;;;;;AAUK;AACL;;;AACA;;A;AACC;;;A;AAED;;A;AAEC;A;A;AAGA;A;AAED;AACA;A;;;;;A;A;AAaC;A;AAEA;A;AAEA;A;AAED;A;;;;;AAUA;AACI;;;A;AAEE;;;A;AAEF;AACA;A;;;;;A;AAH8B;A;AAOhC;A;AAT0B;A;AAa5B;AACA;A;AAEC;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAED;A;;;;;;AAMK;AACL;;;AACC;;AACA;;;A;AAEC;A;A;AAKA;A;AAIA;A;AAED;AACA;;A;AACI;;AAAH;;A;AAEC;;A;;AAEA;;A;A;AAGF;;A;;A;;;;;;AAwBD;A;;;;;;AAKA;;A;AACC;;A;;AAEA;;A;AAED;A;;;;AAkBK;AAA0B;A;;;;AAQ1B;A;AAEJ;A;AAED;A;;;;AAWK;AAAyB;A;;;;AAMzB;AAA8B;A;;;;;AAO9B;AACL;A;;;;;;AAWK;AACL;AACA;AACA;A;;;;;;AAMA;;;A;;;;;;AAKK;AACL;A;;;;;;AAWK;AACL;AACA;AACA;A;;;;;;AAMA;;;A;;;;;;AAKK;AACL;A;;;;;;AAWK;AACL;AACA;AACA;A;;;;;;AAWK;AACL;A;;;;;;AAWK;AACL;AACA;AACA;A;;;;;;AAMA;;;A;;;;;;AAKK;AACL;A;;;;;;AAWK;AACL;AACA;AACA;A;;;;;;AAWK;AACL;A;;;;;;AAWK;AACL;AACA;AACA;A;;;;;;AAMA;;;A;;;;;;AAKK;AACL;A;;;;;;AAWK;AACL;AACA;AACA;A;;;;;;AAYK;AACL;A;;;;;;AAaK;AACL;AACA;AACA;A;;;;;;AAOA;;;A;;;;;;AASK;AAEL;;AACA;;AACA;;A;AACK;AACJ;;A;AACC;;A;;AAEA;;A;AAED;;AACA;A;A;AAGA;A;AAED;A;;;;;;AAeK;AACL;;AACA;;AACA;AACA;A;;;;;;AAKK;AACL;;A;AACC;;A;AACC;A;;AAEA;A;A;;AAGD;A;A;;;;;;AAKI;A;AAEJ;A;AAED;A;AAEC;A;AAED;A;AAEC;A;AAEC;AACA;A;A;AAGF;AACA;;A;AACC;;;A;AAID;AACA;AACA;AACI;;;A;AAEF;AACA;AACA;AACA;A;AALyB;A;AAQ3B;AACA;;;AACA;;A;AACC;;A;AACC;AACA;A;AAED;;;A;AAGE;;;AAAH;;;;;A;AACC;;A;AACI;;AAAH;;A;AACC;;;A;A;;AAGE;;AAAH;;A;AACC;;;A;A;A;;A;AAOD;AACA;;;;A;AAED;;A;AACC;;;A;AAEE;;AAAH;;A;AACC;;;A;A;A;AAID;A;AAED;AACA;A;;;;;;AAOK;AACL;AACA;AACA;AACC;;;;A;AAEC;A;A;AAGA;A;A;A;AAIA;A;AAEA;A;AAEA;A;A;AAGF;A;;;;;AAIK;AACL;A;;;;AAuBA;AAIA;A;;;;AAMK;AACL;AACA;A;;;;;;;;;;;;;;;;;;A;A;A;A;A;A;A;A;A;A;;;AAjcA;;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;;A;;A;;A;;A;;A;;A;;A;;A;;A;;A;;A;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AC5UK;AAA4B;A;;;;AAG5B;AACL;A;;;;AAIK;AACL;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;;;;AC3GA;AACA;;A;AAEC;A;AAED;A;;;;;;AAgEK;AACL;;;A;;;;;AAQK;AACL;A;;;;;AAsBK;AACL;;;;A;;;;;;;;AAsBK;AACL;;AACI;A;AACC;;A;AACF;A;AAEE;;;A;AACF;A;AAED;A;A;AAGF;;A;;A;;;;;AAIK;AACL;A;;;;AAGiB;A;A;AAGhB;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAEA;A;AAED;A;;;;AAGkC;AAA7B;AACL;;A;;;;;;AAUiB;A;AAEhB;A;AAED;;;A;;;;;;;AAIA;AACA;AACA;A;AAEC;A;AAOD;A;AAEC;A;AAEG;AACJ;AACA;;;AAAyC;AACxC;AACA;A;;AAED;AAIA;;AACA;AACA;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;;;;AAIuC;AACxC;A;;;;AAGqC;A;AAEpC;AACA;A;AAED;;AACA;;;;AACA;;A;AAEC;;A;A;AAGA;A;A;;;;;AAIwC;AACzC;A;AAEC;AACA;A;AAED;;AACA;;;;AACA;;A;AAEC;;A;A;AAGA;A;A;;;;;AAIwC;A;AAExC;AACA;A;AAED;;AACA;;;;A;AAEC;A;AAED;A;;;;;AAG6C;AAC7C;A;AAEC;AACA;A;AAED;;AACA;;;;A;AAEC;A;AAED;A;;;;AAGgC;A;AAE/B;A;A;AAGA;A;AAEA;A;A;AAGA;A;A;;;AAI8B;AAC/B;A;AAEC;A;AAED;A;AAEC;A;A;;;AAI+B;AAChC;A;AAEC;A;AAED;A;AAEC;A;A;;;AAM8C;AAA1C;AACL;A;AAEC;A;AAED;A;AAEC;A;AAED;A;AAEC;A;A;;;;;AASiC;AAClC;;A;AACC;;A;AAIC;A;AAED;;A;AACC;;A;AAED;AACA;A;AAED;;A;AACC;;;;;A;AAEC;A;AAED;A;;AAEA;;;A;A;;;;;AAIoC;A;AAEpC;AACA;A;AAED;;A;;;;AAG2C;AAC3C;A;;;;AAQ+C;AAA1C;AACL;AACA;AACA;;;;;;AACC;;AACA;;A;AACC;;A;A;AAGA;A;AAEA;A;AAED;AACA;AACA;A;;AAED;A;;;;;;AAIA;;AACA;AAIA;;;;;;AACC;;;A;;AAED;A;;;;;AAO4C;AAAvC;A;AAEJ;AACA;A;AAED;AACI;;AACJ;AACA;;;;;;A;AAEE;A;AAED;;;AACA;AACA;;;;A;;AAED;A;;;;;;AAIA;;;;A;AACC;A;AAED;;;AACA;A;;;;;AAGoC;A;AAEnC;AACA;A;AAED;;AACA;AACA;;A;AAEC;AACA;AACA;A;;AAIA;AACA;;AACA;;A;AAED;A;;;;;AAQ8C;AAAzC;A;AAEJ;AACA;A;AAED;A;;;;;;AAKA;;;;A;AACC;A;AAED;;AACA;A;;;;;AAO8C;AAAzC;AACL;AACA;AACI;;;A;AAEF;A;AAED;;;;AAJkB;A;AAMnB;A;;;;;;AAIA;;;AACA;A;;;;;AAO4C;AAAvC;A;AAEJ;AACA;A;AAED;;;;;A;;;;;;AAIA;;;AACA;A;;;;;AAOiD;AAA5C;AACL;;A;AACC;A;;AAEA;A;A;;;;;AAOD;AACA;A;;;A;AAKC;A;AAED;;;;;;A;A;AAQG;A;A;;AAIH;A;;;;AAGiB;AACjB;;;;;AACC;;A;A;AAEE;A;AAED;;A;AAED;;A;;AAED;A;;;;;AAIA;;;;;AACC;;;A;AACC;;A;AAED;;A;;AAED;A;;;;AAOK;AAAuC;A;;;;AACvC;AAAuC;;;;A;;;;;AACvC;AAAuC;;;;A;;;;;;AACvC;AAAuC;;;A;;;;;AAGvC;AACL;AACA;AACA;AACI;;;AACA;A;A;AAED;AACA;A;A;AAGA;A;A;A;AAIA;AACA;A;AAEA;AACA;A;AAEA;AACA;A;AAEA;AACA;A;AAMA;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;AACA;A;;;;AAIK;AACL;AACA;AACA;AACI;;;AACA;A;A;AAED;AACA;A;A;AAGA;A;A;A;AAIA;AACA;A;AAEA;AACA;A;AAEA;AACA;A;AAEA;AACA;A;AAMA;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;AACA;A;;;;AAgBc;AACd;AACA;AACA;A;;;AAQK;AAAsB;A;;;;AAEtB;AAA2B;;;;A;;;;AAE3B;A;AAEJ;A;A;AAGA;A;A;AAGA;A;AAED;A;;;;AAMK;AAAuB;A;;;;AAEvB;AAA4B;;;;A;;;;AAE5B;AACL;;;;;;A;AAEE;A;A;AAGA;A;A;;AAGF;A;;;;;AAQA;AACA;AAGA;AACA;AAGA;AAGI;AAEJ;;AACC;;;;AACA;;;;AAEA;;;;;AACC;;A;AACC;;A;AAED;AAGI;;;;AACH;;AACA;;A;AAFiC;A;A;AAKjC;AACA;;A;AANiC;A;A;AASjC;;;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;A;AAaC;A;AAvD+B;A;A;AA6DjC;AACA;;A;AACC;;;A;AA/DgC;A;A;;A;AAqEpC;AAQA;AACI;;;;;;AAGH;AACA;AACI;;;AACH;A;AAEC;A;AAHwC;A;A;AAOzC;AAZuC;A;A;AAexC;;;A;AAEC;A;AAjBuC;A;AAqBzC;AACA;AAEA;A;;;;AAaA;AACA;AACA;;;;;;A;AAEE;AACA;A;A;A;AAMC;A;AAED;A;A;;A;AAID;A;A;AAMA;A;AAED;A;;;;AAUA;AACA;AACA;A;AAEC;A;AAKD;;A;AAEC;A;AAGD;A;AAEC;A;AAED;AACA;AACA;A;;;;AC5oCA;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;;;;ACYK;AAAiC;A;;;;AA4EjC;AACL;AACA;AACA;AACA;AACA;A;;;;;AAKK;A;AAEJ;A;A;AAGA;A;AAED;;A;AAEC;A;A;AAGA;A;AAED;A;;;;;AAIK;AACL;A;;;;AAKK;AACL;AACA;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;;;AAIK;AACL;AACA;AACA;A;;;;A;AAOC;A;A;AAGA;A;AAID;AACA;A;;;ACzkBG;A;AACF;A;AAED;A;;;AAMK;A;AAEJ;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACCA;A;;;AAGW;AACX;A;;;AAOA;AAEA;A;;;;AAGiB;AACjB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAEA;;;;;;AACC;AACA;A;;AAGD;A;;;;AAQK;AACL;A;;;;AAGK;AACL;A;;;;AAGK;AACL;A;;;;AAKqB;AAAJ;AACjB;AACA;AACA;AAEA;A;;;AAIK;AACL;A;;;;AAIK;AACL;AACA;AACA;AACI;AAEA;;;A;AAEF;A;AAED;AACA;AALyB;A;AAQ1B;AACA;;AACC;AACI;;;A;A;AAGD;A;AAED;A;AALiC;A;A;AASlC;A;AAED;AACI;;;A;A;AAGD;A;AAED;A;AALiC;A;A;AASlC;A;AAED;AACA;A;AAED;A;;;;AC7GA;AAQA;;;;;AACC;A;;AAED;A;;;;AAGK;AACL;AACI;;;AACH;A;AAEC;;AACC;A;A;A;A;AAOD;A;AAED;AAbmB;;AAepB;A;;;;AAGK;AACL;AACA;AACA;AACA;AACA;;AACC;AACA;AACA;;A;AAEC;A;A;AAGF;;AACC;AACA;AACA;;A;AAEC;A;A;AAGF;AACI;;;AACH;AACA;;;A;AAEC;AACA;AACA;A;AANqC;A;A;AAUtC;A;A;A;;;;AAOD;AACA;;;;;;A;A;;A;;;A;AAEE;A;A;;AAGF;A;;;AAIA;AACA;AACA;AACI;;;AACH;AACA;AACA;AACA;A;AAJwC;A;A;AAQxC;AACA;A;AAGC;A;A;AAIA;A;AAEC;A;AAEA;A;AAED;AACA;AACA;;AACC;AACA;A;AAED;A;AAGC;A;AA/BsC;A;A;A;AAoCvC;;AACC;AACA;A;AAED;A;AAEA;;AACC;AACA;A;AAED;A;AA9CuC;A;A;;;;AAoDzC;AAEA;AACA;AAGA;AACA;;A;AACC;AACA;;;AACA;AACA;AACA;A;;AAEA;A;AAED;A;;;;AAIA;AACA;AACA;AACA;AACA;AAEA;;;;;;AACC;A;;AAGD;A;;;AAMA;A;;;;AC9KqB;AACrB;;;A;;;;;;;;;;;;;A;A;A;A;A;A;A;A;A"} diff --git a/contrib/backends/srndv2/src/github.com/ZiRo-/cuckgo/miner_js/siphash-lib.js b/contrib/backends/srndv2/src/github.com/ZiRo-/cuckgo/miner_js/siphash-lib.js new file mode 100644 index 0000000..371dd99 --- /dev/null +++ b/contrib/backends/srndv2/src/github.com/ZiRo-/cuckgo/miner_js/siphash-lib.js @@ -0,0 +1,94 @@ +var SipHash = (function() { + function u8to64(p , i) { + return { l: (p[i] | p[i+1]<<8 | p[i+2]<<16 | p[i+3]<<24) , h: (p[i+4] | p[i+5]<<8 | p[i+6]<<16 | p[i+7]<<24) }; + } + + + function _add(a, b) { + var rl = a.l + b.l, + a2 = { h: a.h + b.h + (rl / 2 >>> 31) >>> 0, + l: rl >>> 0 }; + a.h = a2.h; a.l = a2.l; + } + + function _xor(a, b) { + a.h ^= b.h; a.h >>>= 0; + a.l ^= b.l; a.l >>>= 0; + } + + function _rotl(a, n) { + var a2 = { + h: a.h << n | a.l >>> (32 - n), + l: a.l << n | a.h >>> (32 - n) + }; + a.h = a2.h; a.l = a2.l; + } + + function _rotl32(a) { + var al = a.l; + a.l = a.h; a.h = al; + } + + function _compress(v0, v1, v2, v3) { + _add(v0, v1); + _add(v2, v3); + _rotl(v1, 13); + _rotl(v3, 16); + _xor(v1, v0); + _xor(v3, v2); + _rotl32(v0); + _add(v2, v1); + _add(v0, v3); + _rotl(v1, 17); + _rotl(v3, 21); + _xor(v1, v2); + _xor(v3, v0); + _rotl32(v2); + } + + + function hash(v0h, v0l, v1h, v1l, v2h, v2l, v3h, v3l, mh, ml) { + var mi = { h: mh, l: ml }; + + var v0 = { h: v0h, l: v0l }; + var v1 = { h: v1h, l: v1l }; + var v2 = { h: v2h, l: v2l }; + var v3 = { h: v3h, l: v3l }; + + /*var k0 = u8to64(key, 0); + var k1 = u8to64(key, 8); + + var v0 = { h: k0.h, l: k0.l }, v2 = k0; + var v1 = { h: k1.h, l: k1.l }, v3 = k1; + + _xor(v0, { h: 0x736f6d65, l: 0x70736575 }); + _xor(v1, { h: 0x646f7261, l: 0x6e646f6d }); + _xor(v2, { h: 0x6c796765, l: 0x6e657261 }); + _xor(v3, { h: 0x74656462, l: 0x79746573 });*/ + + _xor(v3, mi); + _compress(v0, v1, v2, v3); + _compress(v0, v1, v2, v3); + _xor(v0, mi); + _xor(v2, { h: 0, l: 0xff }); + _compress(v0, v1, v2, v3); + _compress(v0, v1, v2, v3); + _compress(v0, v1, v2, v3); + _compress(v0, v1, v2, v3); + + var h = v0; + _xor(h, v1); + _xor(h, v2); + _xor(h, v3); + + var res = new Uint32Array(2); + res[0]=h.h; res[1]=h.l; + return res; + }; + + return { + hash: hash, + }; +})(); + +var module = module || { }, exports = module.exports = SipHash; diff --git a/contrib/backends/srndv2/src/github.com/ZiRo-/cuckgo/miner_js/verify-json.go b/contrib/backends/srndv2/src/github.com/ZiRo-/cuckgo/miner_js/verify-json.go new file mode 100644 index 0000000..0edd9bc --- /dev/null +++ b/contrib/backends/srndv2/src/github.com/ZiRo-/cuckgo/miner_js/verify-json.go @@ -0,0 +1,69 @@ +/* +The MIT License (MIT) + +Copyright (c) 2016 ZiRo + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. +*/ + +package main + +import ( + "crypto/sha256" + "encoding/json" +) + +type CuckooJSON struct { + Parameter map[string]uint64 `json:"parameters"` + InputData []byte `json:"header"` //sha256 bytes + Cycle []uint64 `json:"cycle"` +} + +func DecodeCuckooJSON(jsonBlob []byte) (*CuckooJSON, error) { + res := new(CuckooJSON) + err := json.Unmarshal(jsonBlob, res) + if err != nil { + return nil, err + } + return res, nil +} + +func EncodeCuckooJSON(cuck CuckooJSON) ([]byte, error) { + return json.Marshal(cuck) +} + +func VerifyJSON(cuck CuckooJSON) bool { + easy := cuck.Parameter["easiness"] + + if easy <= 0 || easy >= SIZE { + return false + } + + if len(cuck.InputData) != sha256.Size { + return false + } + + if uint64(len(cuck.Cycle)) != PROOFSIZE { + return false + } + + var sha [sha256.Size]byte + copy(sha[:], cuck.InputData) + + c := NewCuckooSHA(sha) + return c.Verify(cuck.Cycle, easy) +}